@milaboratories/pl-model-common 1.46.2 → 1.46.4

package/dist/drivers/pframe/query/query_common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_common.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_common.ts"],"mappings":"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"}
+{"version":3,"file":"query_common.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_common.ts"],"mappings":";;;;;AA4ByB;AAuBzB;;;KA3BY,cAAA;EA2BmB,mEAzB7B,IAAA,EAAM,aAAA,IAmDwB;EAjD9B,MAAA,EAAQ,eAAe;AAAA;AAiDO;AAgBhC;;;;AAAoC;AAkCpC;;;;AAEO;AAmBP;;;;;;;AAvEgC,KA1BpB,mBAAA;;AAoGF;AAwBV;;;;;;;;;;;AAKgB;KAvGJ,oBAAA;;;;;;;;;;;AAqIF;AAsBV;;;KA3IY,wBAAA;;;AAkJF;AA4BV;;;;;;;;;;;;;KA5IY,YAAA;EACV,IAAA;EACA,KAAK;AAAA;AAiJG;AAuBV;;;;;;;;;;;AAOiB;AAsBjB;;;AApDU,UA9HO,UAAA;EACf,IAAA;EAkLA;EAhLA,KAAA,EAAO,CAAC;AAAA;;;AAoLH;AAoBP;;;;;;;;;;;AAOiB;AAqCjB;;;;;;UA5NiB,YAAA;EACf,IAAA;EAgOA;EA9NA,KAAA,EAAO,CAAA;EAqOP;EAnOA,WAAA,EAAa,CAAC;AAAA;;AA8ON;AAiBV;;;;;;;;;AAGU;AAuBV;;;;;;;UAhQiB,gBAAA;EACf,IAAA;EAmQQ;EAjQR,OAAA,EAAS,mBAAA;EAuRc;EArRvB,KAAA,EAAO,CAAC;AAAA;;;;;;;;;;AA4RF;AAeR;;;;;;;;;UArRiB,iBAAA;EACf,IAAA;EAyR2B;EAvR3B,OAAA,EAAS,oBAAA;EA+RyB;EA7RlC,IAAA,EAAM,CAAA;EAiSC;EA/RP,KAAA,EAAO,CAAA;AAAA;;;;;AA+RA;AAyBT;;;;;;;;;;;;;;;;;;;;UA5RiB,qBAAA;EACf,IAAA;EAwUqB;EAtUrB,OAAA,EAAS,wBAAA;EAsUY;EApUrB,IAAA,EAAM,CAAA;EAgVS;EA9Uf,KAAA,EAAO,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;UAuBQ,gBAAA;EACf,IAAA;EA+TgC;EA7ThC,KAAA,EAAO,CAAC;EA6T6C;EA3TrD,KAAA;EA2TyD;EAzTzD,eAAA;AAAA;;;;;;;;;AAqWQ;AAkBV;;;;;;;;;AAGU;UApWO,eAAA;EACf,IAAA;EAsWqC;EApWrC,KAAA,EAAO,CAAC;EAqWE;EAnWV,KAAA;AAAA;;;;;;;;;;;;;;;;;;UAoBe,kBAAA;EACf,IAAA;EAmVgC;EAjVhC,KAAA,EAAO,CAAC;EAkVE;EAhVV,KAAA;EAgVsC;EA9UtC,eAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCe,uBAAA;EACf,IAAA;EAuSgC;EArShC,KAAA,EAAO,CAAC;EAqSqC;EAnS7C,KAAA;EAoSU;;;;EA/RV,QAAA;EAgSU;EA9RV,eAAA;EA8RiD;;;;EAzRjD,iBAAA;EA0RuD;;;AAAS;AAwBlE;EA5SE,QAAA;AAAA;;;;;;;AA+SK;AAoBP;;;;;;;UAlTiB,gBAAA;EACf,IAAA;EAoTK;EAlTL,KAAA,EAAO,CAAC;AAAA;;;;;;;;;;;;;;;AA4ToE;AA4B9E;;;;;UAjUiB,mBAAA;EAsUF;EApUb,IAAA;EA+T8B;EA7T9B,KAAA,EAAO,CAAC;AAAA;;;;;;AAkUK;AAoCf;;;;;;;;;;;;;UAhViB,QAAA;EACf,IAAA;EAsXe;EApXf,KAAA,EAAO,CAAA;EAoXiB;EAlXxB,GAAA,EAAK,CAAC;EAkXmB;EAhXzB,MAAA;AAAA;;;;;;;;;AA8XY;AAoCd;;;UAnZiB,QAAA;EACf,IAAA;EAkZ8B;EAhZ9B,KAAA,EAAO,CAAA;EAmZP;EAjZA,UAAA,EAAY,eAAe;AAAA;;;AAmZf;AAkBd;;UA7ZiB,mBAAA;EAgaN;EA9ZT,IAAA,EAAM,CAAA;EA2ZyB;EAzZ/B,IAAA,EAAM,CAAC;AAAA;;;AA4ZE;AAsBX;;;;;;;;;;;AAKwB;AA4CxB;;;;;;;UA1ciB,eAAA;EACf,IAAA;EAycwC;EAvcxC,KAAA,GAAQ,mBAAA,CAAoB,CAAA,MAAO,mBAAA,CAAoB,CAAA;EAucT;EArc9C,SAAA,GAAY,CAAA;AAAA;;KAwCF,WAAA;;;;;;AAyaI;AAoChB;;;;UAjciB,WAAA;EACf,IAAA;EAkcA;EAhcA,IAAA,EAAM,WAAA;EAkcG;EAhcT,OAAA,EAAS,CAAA;EAgcE;EA9bX,SAAA;EA8c6B;EA5c7B,WAAA,IAAe,aAAA,CAAc,CAAA,EAAG,CAAA,MAAO,aAAA,CAAc,CAAA,EAAG,CAAA;AAAA;;;;;AA8chD;AAkCV;;;;;;;;;;UAvciB,WAAA;EACf,IAAA;EAycA;EAvcA,KAAA,EAAO,CAAC;AAAA;;;AAycK;AAcf;;;;AAAgC;AAShC;;;;;;;UA9ciB,aAAA;EACf,IAAA;EAqde;EAndf,KAAA,EAAO,CAAC;AAAA;AAAA,KAGE,2BAAA,OACV,CAAA,SAAU,qBAAA,YAAiC,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YACxD,CAAA,SAAU,gBAAA,YAA4B,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YACnD,CAAA,SAAU,kBAAA,YAA8B,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YACrD,CAAA,SAAU,uBAAA,YAAmC,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YAC1D,CAAA,SAAU,eAAA,YAA2B,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YAClD,CAAA,SAAU,UAAA,YAAsB,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YAC7C,CAAA,SAAU,gBAAA,YAA4B,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YACnD,CAAA,SAAU,mBAAA,YAA+B,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA,YACtD,CAAA,SAAU,QAAA,6BAAqC,OAAA,CAAQ,CAAA;EAAK,IAAA;AAAA;AA2dQ;;;;;;;;;;;;;;;;;AAAA,UAncrD,iBAAA;EACf,IAAA;;EAEA,EAAA,EAAI,CAAC;AAAA;;;;;;;;;;;;;;;;;;UAoBU,mBAAA;EACf,IAAA;;EAEA,EAAA,EAAI,CAAC;AAAA;;;;;;;;KAUK,aAAA,SAAsB,iBAAA,CAAkB,CAAA,IAAK,mBAAA,CAAoB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4B5D,cAAA,YAA0B,cAAA;EACzC,IAAA;;EAEA,OAAA,EAAS,EAAA;;EAET,SAAA,EAAW,EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoCI,cAAA;EACf,IAAA;;EAEA,KAAA,EAAO,CAAA;;EAEP,WAAA;gGAEE,YAAA,EAAc,CAAC;IAEf,QAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8Ba,SAAA;EACf,IAAA;;EAEA,KAAA,EAAO,CAAA;;EAEP,MAAA;IACE,UAAA,EAAY,CAAC;IAEb,SAAA;;;;;;IAMA,UAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoCa,WAAA;EACf,IAAA;;EAEA,KAAA,EAAO,CAAA;;EAEP,SAAA,EAAW,CAAC;AAAA;;;;;;;;;;;;;;;;UAkBG,WAAA,KAAgB,SAAA;EAC/B,IAAA;;EAEA,MAAA,EAAQ,CAAC;AAAA;;;;;;;;;;;;;;;;;;;;UAsBM,iBAAA;EACf,IAAA;;EAEA,IAAA,EAAM,CAAA;;EAEN,QAAA,EAAU,YAAY;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4CP,wBAAA;EACf,IAAA;;EAEA,MAAA,EAAQ,CAAA;;EAER,YAAA,GAAe,EAAA;;;;;;;EAOf,IAAA,GAAO,CAAA,KAAM,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoCE,kBAAA,YAA8B,cAAA;;EAE7C,IAAA;;EAEA,OAAA,EAAS,EAAE;AAAA;;;;;;;;;;;;;;UAgBI,cAAA;;EAEf,KAAA,EAAO,CAAC;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkCO,eAAA,eAA8B,cAAA;EAC7C,IAAA;;EAEA,MAAA,EAAQ,CAAA;;EAER,SAAA,EAAW,EAAA;AAAA;;;;;;;;;;;;KAcD,oBAAA;;;;;;;;UASK,oBAAA;;EAEf,UAAA,EAAY,CAAA;;;;;;EAMZ,YAAA,GAAe,EAAE;AAAA;;;;;;;;;;;UAaF,qBAAA;EACf,IAAA;;EAEA,KAAA,EAAO,CAAA;;EAEP,IAAA,EAAM,oBAAA;;EAEN,OAAA,GAAU,oBAAA,CAAqB,CAAA,EAAG,EAAA,MAAQ,oBAAA,CAAqB,CAAA,EAAG,EAAA;AAAA"}

package/dist/drivers/pframe/query/query_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_data.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_data.ts"],"mappings":";;;;;;AAiCwB;;;KAQnB,mBAAA;EAEH,sCAAA,EAAA,EAAI,SAAA,EAEJ;EAAA,IAAA,EAAM,cAAA;AAAA;;AAeR;;;;;;;;;AAMA;;UANiB,kBAAA,SAA2B,cAAA,CAAe,SAAA;EAM7B;EAJ5B,WAAA;AAAA;;KAIU,eAAA,GAAkB,WAAA;;KAElB,qBAAA,GAAwB,iBAAA,CAAkB,mBAAA;AAEtD;AAAA,KAAY,4BAAA,GAA+B,wBAAA,CACzC,SAAA,UAEA,mBAAA;;KAGU,sBAAA,GAAyB,kBAAA,CAAmB,kBAAA;;KAE5C,kBAAA,GAAqB,cAAA,CAAe,kBAAA;;;;;;;;AAFhD;KAWY,yBAAA;iCAEV,MAAA,EAAQ,SAAA,EAbgE;EAexE,WAAA,YAb4B;EAe5B,kBAAA;AAAA;;KAGU,mBAAA,GAAsB,eAAA,CAAgB,yBAAA,EAA2B,kBAAA;;KAEjE,kBAAA,GAAqB,cAAA,CAAe,SAAA;;KAEpC,aAAA,GAAgB,SAAA,CAAU,SAAA,EAAW,mBAAA;;KAErC,eAAA,GAAkB,WAAA,CAAY,SAAA,EAAW,0BAAA;;KAEzC,yBAAA,GAA4B,qBAAA,CACtC,SAAA,EACA,mBAAA,EACA,mBAAA;;AAXF;;;;;;;;;;KAyBY,SAAA,GACR,eAAA,GACA,qBAAA,GACA,4BAAA,GACA,sBAAA,GACA,kBAAA,GACA,mBAAA,GACA,kBAAA,GACA,aAAA,GACA,eAAA,GACA,yBAAA;;KAGQ,eAAA,GAAkB,WAAA;AApC9B;AAAA,KAsCY,iBAAA,GAAoB,aAAA;AAAA,KAEpB,mBAAA,GACR,iBAAA,GACA,eAAA,GACA,YAAA,GACA,iBAAA,CAAkB,mBAAA,IAClB,qBAAA,CAAsB,mBAAA,IACtB,gBAAA,CAAiB,mBAAA,IACjB,gBAAA,CAAiB,mBAAA,IACjB,kBAAA,CAAmB,mBAAA,IACnB,eAAA,CAAgB,mBAAA,IAChB,uBAAA,CAAwB,mBAAA,IACxB,UAAA,CAAW,mBAAA,IACX,YAAA,CAAa,mBAAA,IACb,gBAAA,CAAiB,mBAAA,IACjB,mBAAA,CAAoB,mBAAA,IACpB,QAAA,CAAS,mBAAA,YACT,QAAA,CAAS,mBAAA,YAET,QAAA,CAAS,mBAAA,IACT,eAAA,CAAgB,mBAAA,IAEhB,WAAA,CAAY,mBAAA;AAAA,KAGJ,0BAAA,GAA6B,2BAAA,CAA4B,mBAAA"}
+{"version":3,"file":"query_data.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_data.ts"],"mappings":";;;;;;AAiCwB;;;KAQnB,mBAAA;EAEH,sCAAA,EAAA,EAAI,SAAA,EAEJ;EAAA,IAAA,EAAM,cAAc;AAAA;AAAA;AAetB;;;;;;;;AAEa;AAIb;;AArBsB,UAeL,kBAAA,SAA2B,cAAc,CAAC,SAAA;EAMlB;EAJvC,WAAA;AAAA;;KAIU,eAAA,GAAkB,WAAW;;KAE7B,qBAAA,GAAwB,iBAAiB,CAAC,mBAAA;AAEtD;AAAA,KAAY,4BAAA,GAA+B,wBAAA,CACzC,SAAA,UAEA,mBAAA;;KAGU,sBAAA,GAAyB,kBAAkB,CAAC,kBAAA;;KAE5C,kBAAA,GAAqB,cAAc,CAAC,kBAAA;;;;;;;AAL3B;AAGrB;KAWY,yBAAA;iCAEV,MAAA,EAAQ,SAAS,EAbuD;EAexE,WAAA,YAb4B;EAe5B,kBAAA;AAAA;AAfgE;AAAA,KAkBtD,mBAAA,GAAsB,eAAA,CAAgB,yBAAA,EAA2B,kBAAA;;KAEjE,kBAAA,GAAqB,cAAc,CAAC,SAAA;;KAEpC,aAAA,GAAgB,SAAA,CAAU,SAAA,EAAW,mBAAA;;KAErC,eAAA,GAAkB,WAAA,CAAY,SAAA,EAAW,0BAAA;;KAEzC,yBAAA,GAA4B,qBAAA,CACtC,SAAA,EACA,mBAAA,EACA,mBAAA;AAdkB;AAGpB;;;;;;;;;;AAHoB,KA4BR,SAAA,GACR,eAAA,GACA,qBAAA,GACA,4BAAA,GACA,sBAAA,GACA,kBAAA,GACA,mBAAA,GACA,kBAAA,GACA,aAAA,GACA,eAAA,GACA,yBAAA;;KAGQ,eAAA,GAAkB,WAAW;AApCzC;AAAA,KAsCY,iBAAA,GAAoB,aAAa;AAAA,KAEjC,mBAAA,GACR,iBAAA,GACA,eAAA,GACA,YAAA,GACA,iBAAA,CAAkB,mBAAA,IAClB,qBAAA,CAAsB,mBAAA,IACtB,gBAAA,CAAiB,mBAAA,IACjB,gBAAA,CAAiB,mBAAA,IACjB,kBAAA,CAAmB,mBAAA,IACnB,eAAA,CAAgB,mBAAA,IAChB,uBAAA,CAAwB,mBAAA,IACxB,UAAA,CAAW,mBAAA,IACX,YAAA,CAAa,mBAAA,IACb,gBAAA,CAAiB,mBAAA,IACjB,mBAAA,CAAoB,mBAAA,IACpB,QAAA,CAAS,mBAAA,YACT,QAAA,CAAS,mBAAA,YAET,QAAA,CAAS,mBAAA,IACT,eAAA,CAAgB,mBAAA,IAEhB,WAAA,CAAY,mBAAA;AAAA,KAGJ,0BAAA,GAA6B,2BAA2B,CAAC,mBAAA"}

package/dist/drivers/pframe/query/query_spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_spec.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_spec.ts"],"mappings":";;;;;;;;;;AA6CA;;;;;KAAY,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,SAAA,CAAU,CAAA;EACvE,cAAA;IAEQ,uBAAN,IAAA,EAAM,kBAAA,EAEe;IAArB,aAAA,EAAe,MAAA;EAAA;AAAA;;KAKP,eAAA,KAAoB,SAAA,IAAa,WAAA,CAAY,CAAA;;KAE7C,qBAAA,GAAwB,iBAAA,CAAkB,gBAAA;;KAE1C,4BAAA,KAAiC,SAAA,IAAa,wBAAA,CACxD,CAAA,EACA,kBAAA,EACA,gBAAA;;KAGU,sBAAA,KAA2B,SAAA,IAAa,kBAAA,CAAmB,kBAAA,CAAmB,CAAA;;KAE9E,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,kBAAA,CAAmB,CAAA;AAZlF;;;;;;AAAA,KAmBY,yBAAA,KAA8B,SAAA;EAnBc,+BAqBtD,MAAA,EAAQ,CAAA;AAAA;;KAGE,mBAAA,KAAwB,SAAA,IAAa,eAAA,CAC/C,yBAAA,CAA0B,CAAA,GAC1B,kBAAA,CAAmB,CAAA;;KAGT,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,SAAA,CAAU,CAAA,GAAI,kBAAA;AA3B7E;AAAA,KA6BY,aAAA,KAAkB,SAAA,IAAa,SAAA,CAAU,SAAA,CAAU,CAAA,GAAI,mBAAA;;KAEvD,eAAA,KAAoB,SAAA,IAAa,WAAA,CAAY,SAAA,CAAU,CAAA,GAAI,0BAAA;;KAE3D,yBAAA,KAA8B,SAAA,IAAa,qBAAA,CACrD,SAAA,CAAU,CAAA,GACV,mBAAA,EACA,gBAAA;;;;;;;;;;;;;;;;KAkBU,SAAA,KAAc,SAAA,IACtB,eAAA,CAAgB,CAAA,IAChB,qBAAA,GACA,4BAAA,CAA6B,CAAA,IAC7B,sBAAA,CAAuB,CAAA,IACvB,kBAAA,CAAmB,CAAA,IACnB,mBAAA,CAAoB,CAAA,IACpB,kBAAA,CAAmB,CAAA,IACnB,aAAA,CAAc,CAAA,IACd,eAAA,CAAgB,CAAA,IAChB,yBAAA,CAA0B,CAAA;;KAGlB,eAAA,GAAkB,WAAA,CAAY,kBAAA;;KAE9B,iBAAA,GAAoB,aAAA,CAAc,SAAA;AAAA,KAElC,mBAAA,GACR,iBAAA,GACA,eAAA,GACA,YAAA,GACA,iBAAA,CAAkB,mBAAA,IAClB,qBAAA,CAAsB,mBAAA,IACtB,gBAAA,CAAiB,mBAAA,IACjB,gBAAA,CAAiB,mBAAA,IACjB,kBAAA,CAAmB,mBAAA,IACnB,eAAA,CAAgB,mBAAA,IAChB,uBAAA,CAAwB,mBAAA,IACxB,UAAA,CAAW,mBAAA,IACX,YAAA,CAAa,mBAAA,IACb,gBAAA,CAAiB,mBAAA,IACjB,mBAAA,CAAoB,mBAAA,IACpB,QAAA,CAAS,mBAAA,YACT,QAAA,CAAS,mBAAA,YAET,QAAA,CAAS,mBAAA,IACT,eAAA,CAAgB,mBAAA,IAEhB,WAAA,CAAY,mBAAA,EAAqB,kBAAA,EAAoB,SAAA;AAAA,KAG7C,0BAAA,GAA6B,2BAAA,CAA4B,mBAAA"}
+{"version":3,"file":"query_spec.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_spec.ts"],"mappings":";;;;;;;;;;AA6CA;;;;;KAAY,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,SAAA,CAAU,CAAA;EACvE,cAAA;IAEQ,uBAAN,IAAA,EAAM,kBAAA,EAEe;IAArB,aAAA,EAAe,MAAA;EAAA;AAAA;;KAKP,eAAA,KAAoB,SAAA,IAAa,WAAA,CAAY,CAAA;;KAE7C,qBAAA,GAAwB,iBAAiB,CAAC,gBAAA;;KAE1C,4BAAA,KAAiC,SAAA,IAAa,wBAAA,CACxD,CAAA,EACA,kBAAA,EACA,gBAAA;;KAGU,sBAAA,KAA2B,SAAA,IAAa,kBAAA,CAAmB,kBAAA,CAAmB,CAAA;;KAE9E,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,kBAAA,CAAmB,CAAA;AAZlF;;;;;;AAAA,KAmBY,yBAAA,KAA8B,SAAA;EAnBc,+BAqBtD,MAAA,EAAQ,CAAC;AAAA;;KAGC,mBAAA,KAAwB,SAAA,IAAa,eAAA,CAC/C,yBAAA,CAA0B,CAAA,GAC1B,kBAAA,CAAmB,CAAA;;KAGT,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,SAAA,CAAU,CAAA,GAAI,kBAAA;AA3B7E;AAAA,KA6BY,aAAA,KAAkB,SAAA,IAAa,SAAA,CAAU,SAAA,CAAU,CAAA,GAAI,mBAAA;;KAEvD,eAAA,KAAoB,SAAA,IAAa,WAAA,CAAY,SAAA,CAAU,CAAA,GAAI,0BAAA;AA/BD;AAAA,KAiC1D,yBAAA,KAA8B,SAAA,IAAa,qBAAA,CACrD,SAAA,CAAU,CAAA,GACV,mBAAA,EACA,gBAAA;;;;;;;;;;;;;;;;KAkBU,SAAA,KAAc,SAAA,IACtB,eAAA,CAAgB,CAAA,IAChB,qBAAA,GACA,4BAAA,CAA6B,CAAA,IAC7B,sBAAA,CAAuB,CAAA,IACvB,kBAAA,CAAmB,CAAA,IACnB,mBAAA,CAAoB,CAAA,IACpB,kBAAA,CAAmB,CAAA,IACnB,aAAA,CAAc,CAAA,IACd,eAAA,CAAgB,CAAA,IAChB,yBAAA,CAA0B,CAAA;AA3DZ;AAAA,KA8DN,eAAA,GAAkB,WAAW,CAAC,kBAAA;;KAE9B,iBAAA,GAAoB,aAAa,CAAC,SAAA;AAAA,KAElC,mBAAA,GACR,iBAAA,GACA,eAAA,GACA,YAAA,GACA,iBAAA,CAAkB,mBAAA,IAClB,qBAAA,CAAsB,mBAAA,IACtB,gBAAA,CAAiB,mBAAA,IACjB,gBAAA,CAAiB,mBAAA,IACjB,kBAAA,CAAmB,mBAAA,IACnB,eAAA,CAAgB,mBAAA,IAChB,uBAAA,CAAwB,mBAAA,IACxB,UAAA,CAAW,mBAAA,IACX,YAAA,CAAa,mBAAA,IACb,gBAAA,CAAiB,mBAAA,IACjB,mBAAA,CAAoB,mBAAA,IACpB,QAAA,CAAS,mBAAA,YACT,QAAA,CAAS,mBAAA,YAET,QAAA,CAAS,mBAAA,IACT,eAAA,CAAgB,mBAAA,IAEhB,WAAA,CAAY,mBAAA,EAAqB,kBAAA,EAAoB,SAAA;AAAA,KAG7C,0BAAA,GAA6B,2BAA2B,CAAC,mBAAA"}

package/dist/drivers/pframe/query/utils.cjs

@@ -1,7 +1,7 @@
 const require_util = require("../../../util.cjs");
 const require_json = require("../../../json.cjs");
 //#region src/drivers/pframe/query/utils.ts
-const BOOLEAN_TYPES = new Set([
+const BOOLEAN_TYPES = /* @__PURE__ */ new Set([
 	"numericComparison",
 	"stringEquals",
 	"stringContains",

package/dist/drivers/pframe/query/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["canonicalizeJson"],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\":\n      result = {\n        ...query,\n        linker: { ...query.linker, column: visitor.column(query.linker.column) },\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  cb: (c: C1) => C2,\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, { column: cb });\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      if (lhs.linker.column !== rhsLinker.linker.column) {\n        return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;\n      }\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":";;;AASA,MAAM,gBAAgB,IAAI,IAAwC;CAChE;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAED,CAAC;AAEF,SAAgB,oBAAoB,MAA+D;AACjG,QAAO,cAAc,IAEnB,KAAK,KACN;;;;;;;;;;;;AAaH,SAAgB,kBACd,OACA,SAQe;CACf,MAAM,iBAAiB,UAA0D;EAC/E,MAAM,YAAoC;GACxC,GAAG;GACH,OAAO,kBAAkB,MAAM,OAAO,QAAQ;GAC/C;AACD,SAAO,QAAQ,YAAY,QAAQ,UAAU,UAAU,GAAG;;CAG5D,IAAI;AACJ,SAAQ,MAAM,MAAd;EACE,KAAK;AACH,YAAS;IAAE,MAAM;IAAU,QAAQ,QAAQ,OAAO,MAAM,OAAO;IAAE;AACjE;EACF,KAAK;AACH,YAAS;IAAE,GAAG;IAAO,QAAQ,QAAQ,OAAO,MAAM,OAAO;IAAE;AAC3D;EACF,KAAK;AACH,YAAS;AACT;EACF,KAAK;EACL,KAAK;AACH,YAAS;IAAE,GAAG;IAAO,SAAS,MAAM,QAAQ,IAAI,cAAc;IAAE;AAChE;EACF,KAAK;AACH,YAAS;IACP,GAAG;IACH,SAAS,cAAc,MAAM,QAAQ;IACrC,WAAW,MAAM,UAAU,IAAI,cAAc;IAC9C;AACD;EACF,KAAK;AACH,YAAS;IACP,GAAG;IACH,QAAQ;KAAE,GAAG,MAAM;KAAQ,QAAQ,QAAQ,OAAO,MAAM,OAAO,OAAO;KAAE;IACxE,WAAW,MAAM,UAAU,IAAI,cAAc;IAC9C;AACD;EACF,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;AACH,YAAS;IAAE,GAAG;IAAO,OAAO,kBAAkB,MAAM,OAAO,QAAQ;IAAE;AACrE;EACF,QACE,cAAA,YAAY,MAAM;;AAGtB,QAAO,QAAQ,OAAO,QAAQ,KAAK,OAAO,GAAG;;;AAI/C,SAAgB,oBACd,OACA,IACe;AACf,QAAO,kBAAkB,OAAO,EAAE,QAAQ,IAAI,CAAC;;;AAIjD,SAAgB,wBAA2B,OAA0B;CACnE,MAAM,SAAc,EAAE;AACtB,mBAAkB,OAAO,EACvB,SAAS,MAAS;AAChB,SAAO,KAAK,EAAE;AACd,SAAO;IAEV,CAAC;AACF,QAAO;;AAGT,SAAgB,cAAc,OAA6B;AACzD,QAAO,kBAAkB,OAAO;EAC9B,SAAS,MAAM;EACf,OAAO,SAAS;AACd,WAAQ,KAAK,MAAb;IACE,KAAK,sBACH,QAAO;KACL,GAAG;KAGH,MAAM,KAAK,KAAK,UAAU,GAAG,MAC3BA,aAAAA,iBAAiB,EAAE,CAAC,cAAcA,aAAAA,iBAAiB,EAAE,CAAC,CACvD;KACF;IACH,KAAK;IACL,KAAK,YAAY;KACf,MAAM,SAAS,CAAC,GAAG,KAAK,QAAQ,CAAC,KAAK,sBAAsB;AAC5D,YAAO;MAAE,GAAG;MAAM,SAAS;MAAQ;;IAErC,KAAK,aAAa;KAChB,MAAM,SAAS,CAAC,GAAG,KAAK,UAAU,CAAC,KAAK,sBAAsB;AAC9D,YAAO;MAAE,GAAG;MAAM,WAAW;MAAQ;;IAEvC,KAAK,cAAc;KACjB,MAAM,SAAS,CAAC,GAAG,KAAK,UAAU,CAAC,KAAK,sBAAsB;AAC9D,YAAO;MAAE,GAAG;MAAM,WAAW;MAAQ;;IAEvC,KAAK,YACH,QAAO;KACL,GAAG;KACH,aAAa,KAAK,YAAY,UAAU,GAAG,MAAM;MAC/C,MAAM,KAAKA,aAAAA,iBAAiB,EAAE,aAAa;MAC3C,MAAM,KAAKA,aAAAA,iBAAiB,EAAE,aAAa;AAC3C,aAAO,KAAK,KAAK,KAAK,OAAO,KAAK,IAAI;OACtC;KACH;IACH,QACE,QAAO;;;EAGb,YAAY,UAAU;AAGpB,OAAI,MAAM,mBAAmB,KAAA,KAAa,MAAM,eAAe,WAAW,EACxE,QAAO;AAET,UAAO;IACL,GAAG;IACH,gBAAgB,MAAM,eAAe,UAAU,GAAG,MAAM;KACtD,MAAM,KAAKA,aAAAA,iBAAiB,EAAE,KAAK;KACnC,MAAM,KAAKA,aAAAA,iBAAiB,EAAE,KAAK;AACnC,YAAO,KAAK,KAAK,KAAK,OAAO,KAAK,IAAI;MACtC;IACH;;EAEJ,CAAC;;AAGJ,SAAS,aAAa,KAAgB,KAAwB;AAC5D,KAAI,IAAI,SAAS,IAAI,KACnB,QAAO,IAAI,OAAO,IAAI,OAAO,KAAK;AAEpC,SAAQ,IAAI,MAAZ;EACE,KAAK,SACH,QAAO,IAAI,SAAU,IAAmB,SACpC,KACA,IAAI,WAAY,IAAmB,SACjC,IACA;EACR,KAAK,eACH,QAAO,IAAI,KAAK,WAAY,IAAmB,KAAK,WAChD,KACA,IAAI,KAAK,aAAc,IAAmB,KAAK,WAC7C,IACA;EACR,KAAK,sBACH,QAAO,IAAI,SAAU,IAAmB,SACpC,KACA,IAAI,WAAY,IAAmB,SACjC,IACA;EACR,KAAK;EACL,KAAK,YAAY;GACf,MAAM,UAAU;AAChB,OAAI,IAAI,QAAQ,WAAW,QAAQ,QAAQ,OACzC,QAAO,IAAI,QAAQ,SAAS,QAAQ,QAAQ;AAE9C,QAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,QAAQ,KAAK;IAC3C,MAAM,MAAM,sBAAsB,IAAI,QAAQ,IAAI,QAAQ,QAAQ,GAAG;AACrE,QAAI,QAAQ,EAAG,QAAO;;AAExB,UAAO;;EAET,KAAK,aAAa;GAChB,MAAM,WAAW;GACjB,MAAM,MAAM,sBAAsB,IAAI,SAAS,SAAS,QAAQ;AAChE,OAAI,QAAQ,EAAG,QAAO;AACtB,OAAI,IAAI,UAAU,WAAW,SAAS,UAAU,OAC9C,QAAO,IAAI,UAAU,SAAS,SAAS,UAAU;AAEnD,QAAK,IAAI,IAAI,GAAG,IAAI,IAAI,UAAU,QAAQ,KAAK;IAC7C,MAAM,MAAM,sBAAsB,IAAI,UAAU,IAAI,SAAS,UAAU,GAAG;AAC1E,QAAI,QAAQ,EAAG,QAAO;;AAExB,UAAO;;EAET,KAAK,cAAc;GACjB,MAAM,YAAY;AAClB,OAAI,IAAI,OAAO,WAAW,UAAU,OAAO,OACzC,QAAO,IAAI,OAAO,SAAS,UAAU,OAAO,SAAS,KAAK;AAE5D,OAAI,IAAI,UAAU,WAAW,UAAU,UAAU,OAC/C,QAAO,IAAI,UAAU,SAAS,UAAU,UAAU;AAEpD,QAAK,IAAI,IAAI,GAAG,IAAI,IAAI,UAAU,QAAQ,KAAK;IAC7C,MAAM,MAAM,sBAAsB,IAAI,UAAU,IAAI,UAAU,UAAU,GAAG;AAC3E,QAAI,QAAQ,EAAG,QAAO;;AAExB,UAAO;;EAET,KAAK,YACH,QAAO,aAAa,IAAI,OAAQ,IAAmB,MAAM;EAC3D,KAAK,OACH,QAAO,aAAa,IAAI,OAAQ,IAAmB,MAAM;EAC3D,KAAK,SACH,QAAO,aAAa,IAAI,OAAQ,IAAmB,MAAM;EAC3D,KAAK,oBAAoB;GACvB,MAAM,QAAQ;GACd,MAAM,MAAM,aAAa,IAAI,OAAO,MAAM,MAAM;AAChD,OAAI,QAAQ,EAAG,QAAO;GACtB,MAAM,UAAU,IAAI,KAAK,cAAc,MAAM,KAAK;AAClD,OAAI,YAAY,EAAG,QAAO;AAE1B,UAAOA,aAAAA,iBAAiB,IAAI,QAAQ,CAAC,cAAcA,aAAAA,iBAAiB,MAAM,QAAQ,CAAC;;EAErF,QACE,cAAA,YAAY,IAAI;;;AAItB,SAAS,sBAAsB,KAAyB,KAAiC;CACvF,MAAM,MAAM,aAAa,IAAI,OAAO,IAAI,MAAM;AAC9C,KAAI,QAAQ,EAAG,QAAO;CAEtB,MAAM,OAAO,IAAI,kBAAkB,EAAE;CACrC,MAAM,OAAO,IAAI,kBAAkB,EAAE;AACrC,KAAI,KAAK,WAAW,KAAK,OACvB,QAAO,KAAK,SAAS,KAAK;AAE5B,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,IAAIA,aAAAA,iBAAiB,KAAK,GAAG;EACnC,MAAM,IAAIA,aAAAA,iBAAiB,KAAK,GAAG;AACnC,MAAI,MAAM,EAAG,QAAO,IAAI,IAAI,KAAK;;AAEnC,QAAO"}
+{"version":3,"file":"utils.cjs","names":["canonicalizeJson"],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\":\n      result = {\n        ...query,\n        linker: { ...query.linker, column: visitor.column(query.linker.column) },\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  cb: (c: C1) => C2,\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, { column: cb });\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      if (lhs.linker.column !== rhsLinker.linker.column) {\n        return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;\n      }\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":"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"}

package/dist/drivers/pframe/query/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"mappings":";;;iBAuBgB,mBAAA,CAAoB,IAAA,EAAM,mBAAA,GAAsB,IAAA,IAAQ,0BAAA;;AAAxE;;;;;;;;;iBAiBgB,iBAAA,QAAA,CACd,KAAA,EAAO,SAAA,CAAU,EAAA,GACjB,OAAA;EAFc,+EAIZ,MAAA,GAAS,CAAA,EAAG,EAAA,KAAO,EAAA,EAJU;EAM7B,IAAA,IAAQ,IAAA,EAAM,SAAA,CAAU,EAAA,MAAQ,SAAA,CAAU,EAAA,GALrC;EAOL,SAAA,IAAa,KAAA,EAAO,kBAAA,CAAmB,EAAA,MAAQ,kBAAA,CAAmB,EAAA;AAAA,IAEnE,SAAA,CAAU,EAAA;;iBAoDG,mBAAA,QAAA,CACd,KAAA,EAAO,SAAA,CAAU,EAAA,GACjB,EAAA,GAAK,CAAA,EAAG,EAAA,KAAO,EAAA,GACd,SAAA,CAAU,EAAA;;iBAKG,uBAAA,GAAA,CAA2B,KAAA,EAAO,SAAA,CAAU,CAAA,IAAK,CAAA;AAAA,iBAWjD,aAAA,CAAc,KAAA,EAAO,SAAA,GAAY,SAAA"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"mappings":";;;iBAuBgB,mBAAA,CAAoB,IAAA,EAAM,mBAAA,GAAsB,IAAA,IAAQ,0BAA0B;;AAAlG;;;;;;;;;iBAiBgB,iBAAA,SACd,KAAA,EAAO,SAAA,CAAU,EAAA,GACjB,OAAA;EAFc,+EAIZ,MAAA,GAAS,CAAA,EAAG,EAAA,KAAO,EAAA,EAJU;EAM7B,IAAA,IAAQ,IAAA,EAAM,SAAA,CAAU,EAAA,MAAQ,SAAA,CAAU,EAAA,GALrC;EAOL,SAAA,IAAa,KAAA,EAAO,kBAAA,CAAmB,EAAA,MAAQ,kBAAA,CAAmB,EAAA;AAAA,IAEnE,SAAA,CAAU,EAAA;;iBAoDG,mBAAA,SACd,KAAA,EAAO,SAAA,CAAU,EAAA,GACjB,EAAA,GAAK,CAAA,EAAG,EAAA,KAAO,EAAA,GACd,SAAA,CAAU,EAAA;;iBAKG,uBAAA,IAA2B,KAAA,EAAO,SAAA,CAAU,CAAA,IAAK,CAAA;AAAA,iBAWjD,aAAA,CAAc,KAAA,EAAO,SAAA,GAAY,SAAS"}

package/dist/drivers/pframe/query/utils.js

@@ -1,7 +1,7 @@
 import { assertNever } from "../../../util.js";
 import { canonicalizeJson } from "../../../json.js";
 //#region src/drivers/pframe/query/utils.ts
-const BOOLEAN_TYPES = new Set([
+const BOOLEAN_TYPES = /* @__PURE__ */ new Set([
 	"numericComparison",
 	"stringEquals",
 	"stringContains",

package/dist/drivers/pframe/query/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\":\n      result = {\n        ...query,\n        linker: { ...query.linker, column: visitor.column(query.linker.column) },\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  cb: (c: C1) => C2,\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, { column: cb });\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      if (lhs.linker.column !== rhsLinker.linker.column) {\n        return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;\n      }\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\":\n      result = {\n        ...query,\n        linker: { ...query.linker, column: visitor.column(query.linker.column) },\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  cb: (c: C1) => C2,\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, { column: cb });\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      if (lhs.linker.column !== rhsLinker.linker.column) {\n        return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;\n      }\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":"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"}

package/dist/drivers/pframe/spec/anchored.cjs

@@ -2,7 +2,7 @@ const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
 const require_spec = require("./spec.cjs");
 const require_ids = require("./ids.cjs");
 let canonicalize = require("canonicalize");
-canonicalize = require_runtime.__toESM(canonicalize);
+canonicalize = require_runtime.__toESM(canonicalize, 1);
 //#region src/drivers/pframe/spec/anchored.ts
 function axisKey(axis) {
 	return (0, canonicalize.default)(require_spec.getAxisId(axis));
@@ -15,6 +15,7 @@ function domainKey(key, value) {
 * Maintains maps of known domain values and axes that can be referenced by anchors
 */
 var AnchoredIdDeriver = class {
+	anchors;
 	axes = /* @__PURE__ */ new Map();
 	domains = /* @__PURE__ */ new Map();
 	contextDomains = /* @__PURE__ */ new Map();

package/dist/drivers/pframe/spec/anchored.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"anchored.cjs","names":["getAxisId","stringifyColumnId","matchAxisId"],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"sourcesContent":["import canonicalize from \"canonicalize\";\nimport type { AxisFilter, AxisFilterValue } from \"./filtered_column\";\nimport type { SUniversalPColumnId, UniversalPColumnId } from \"./ids\";\nimport { stringifyColumnId } from \"./ids\";\nimport type {\n  AAxisSelector,\n  AnchorAxisRef,\n  AnchorAxisRefByIdx,\n  AnchoredPColumnId,\n  AnchoredPColumnSelector,\n  LegacyAxisSelector,\n  PColumnSelector,\n} from \"./selectors\";\nimport type { AxisId, PColumnSpec } from \"./spec\";\nimport { getAxisId, matchAxisId } from \"./spec\";\n\n//\n// Helper functions\n//\n\nfunction axisKey(axis: AxisId): string {\n  return canonicalize(getAxisId(axis))!;\n}\n\nfunction domainKey(key: string, value: string): string {\n  return JSON.stringify([key, value]);\n}\n\n/**\n * Context for resolving and generating anchored references to columns and axes\n * Maintains maps of known domain values and axes that can be referenced by anchors\n */\nexport class AnchoredIdDeriver {\n  private readonly axes = new Map<string, AnchorAxisRefByIdx>();\n  private readonly domains = new Map<string, string>();\n  private readonly contextDomains = new Map<string, string>();\n  /**\n   * Domain packs are used to group domain keys that can be anchored to the same anchor\n   * This is used to optimize the lookup of domain anchors\n   */\n  private readonly domainPacks: string[][] = [];\n  private readonly contextDomainPacks: string[][] = [];\n  /**\n   * Maps domain packs to anchors\n   */\n  private readonly domainPackToAnchor = new Map<string, string>();\n  private readonly contextDomainPackToAnchor = new Map<string, string>();\n\n  /**\n   * Creates a new anchor context from a set of anchor column specifications\n   * @param anchors Record of anchor column specifications indexed by anchor ID\n   */\n  constructor(\n    public readonly anchors: Record<\n      string,\n      Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">\n    >,\n  ) {\n    const anchorEntries = Object.entries(anchors);\n    anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));\n    for (const [anchorId, spec] of anchorEntries) {\n      for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {\n        const axis = spec.axesSpec[axisIdx];\n        const key = axisKey(axis);\n        this.axes.set(key, { anchor: anchorId, idx: axisIdx });\n      }\n      if (spec.domain !== undefined) {\n        const domainEntries = Object.entries(spec.domain);\n        domainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);\n        this.domainPacks.push(domainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of domainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.domains.set(key, anchorId);\n        }\n      }\n      if (spec.contextDomain !== undefined) {\n        const contextDomainEntries = Object.entries(spec.contextDomain);\n        contextDomainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.contextDomainPackToAnchor.set(JSON.stringify(contextDomainEntries), anchorId);\n        this.contextDomainPacks.push(contextDomainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of contextDomainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.contextDomains.set(key, anchorId);\n        }\n      }\n    }\n  }\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @returns An anchored column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec): AnchoredPColumnId;\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @param axisFilters Axis filters to apply to the column\n   * @returns An anchored and sliced column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId;\n\n  /**\n   * Implementation of derive method\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId {\n    const result: AnchoredPColumnId = {\n      name: spec.name,\n      axes: [],\n    };\n\n    let skipDomains: Set<string> | undefined = undefined;\n    if (spec.domain !== undefined) {\n      outer: for (const domainPack of this.domainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of domainPack) {\n          const dValue = spec.domain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (domainAnchor !== undefined) {\n          result.domainAnchor = domainAnchor;\n          skipDomains = new Set(domainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {\n      if (skipDomains !== undefined && skipDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.domains.get(key);\n      result.domain ??= {};\n      result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    let skipContextDomains: Set<string> | undefined = undefined;\n    if (spec.contextDomain !== undefined) {\n      outer: for (const contextDomainPack of this.contextDomainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of contextDomainPack) {\n          const dValue = spec.contextDomain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const contextDomainAnchor = this.contextDomainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (contextDomainAnchor !== undefined) {\n          result.contextDomainAnchor = contextDomainAnchor;\n          skipContextDomains = new Set(contextDomainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.contextDomain ?? {})) {\n      if (skipContextDomains !== undefined && skipContextDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.contextDomains.get(key);\n      result.contextDomain ??= {};\n      result.contextDomain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    result.axes = spec.axesSpec.map((axis) => {\n      const key = axisKey(axis);\n      const anchorAxisRef = this.axes.get(key);\n      if (anchorAxisRef === undefined) return getAxisId(axis);\n      else return anchorAxisRef;\n    });\n\n    // If no axis filters are provided, return the anchored ID as is\n    if (!axisFilters || axisFilters.length === 0) {\n      return result;\n    }\n\n    // Process axis filters and create a sliced column ID\n    const resolvedFilters: [number, AxisFilterValue][] = [];\n\n    for (const filter of axisFilters) {\n      const [axisIdOrIndex, value] = filter;\n\n      // If it's already a numeric index, validate it\n      if (typeof axisIdOrIndex === \"number\") {\n        if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {\n          throw new Error(\n            `Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`,\n          );\n        }\n        resolvedFilters.push([axisIdOrIndex, value]);\n      } else {\n        // If it's a string (axis name), resolve it to an index\n        const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);\n        if (axisIndex === -1) {\n          throw new Error(\n            `Axis with name \"${axisIdOrIndex}\" not found in the column specification`,\n          );\n        }\n        resolvedFilters.push([axisIndex, value]);\n      }\n    }\n\n    // Sort filters by axis index to ensure consistency\n    resolvedFilters.sort((a, b) => a[0] - b[0]);\n\n    return {\n      source: result,\n      axisFilters: resolvedFilters,\n    };\n  }\n\n  /**\n   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column\n   * @param spec Column specification to anchor\n   * @param axisFilters Optional axis filters to apply to the column\n   * @returns A canonicalized string representation of the anchored column identifier\n   */\n  deriveS(spec: PColumnSpec, axisFilters?: AxisFilter[]): SUniversalPColumnId {\n    return stringifyColumnId(this.derive(spec, axisFilters));\n  }\n}\n\n/**\n * Options for the resolveAnchors function\n */\nexport type ResolveAnchorsOptions = {\n  /**\n   * If true, missing domain keys in anchors will be ignored.\n   * If false (default), an error will be thrown.\n   */\n  ignoreMissingDomains?: boolean;\n};\n\n/**\n * Resolves anchored references in a column matcher to create a non-anchored matcher.\n * Doing an opposite operation to {@link AnchorIdDeriver.derive()}.\n *\n * @param anchors - Record of anchor column specifications indexed by anchor id\n * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved\n * @param options - Options for resolving anchors\n * @returns A non-anchored column matcher with all references resolved to actual values\n * @deprecated - This function by parent PColumnCollection\n */\nexport function resolveAnchors(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">>,\n  matcher: AnchoredPColumnSelector,\n  options?: ResolveAnchorsOptions,\n): PColumnSelector {\n  const result = { ...matcher };\n  const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;\n\n  if (result.domainAnchor !== undefined) {\n    const anchorSpec = anchors[result.domainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.domainAnchor}\" not found`);\n\n    const anchorDomains = anchorSpec.domain || {};\n    result.domain = { ...anchorDomains, ...result.domain };\n    delete result.domainAnchor;\n  }\n\n  if (result.domain) {\n    const resolvedDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.domain)) {\n      if (typeof value === \"string\") {\n        resolvedDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for domain key \"${key}\"`);\n\n        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedDomain[key] = anchorSpec.domain[key];\n      }\n    }\n    result.domain = resolvedDomain;\n  }\n\n  if (result.contextDomainAnchor !== undefined) {\n    const anchorSpec = anchors[result.contextDomainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.contextDomainAnchor}\" not found`);\n\n    const anchorContextDomains = anchorSpec.contextDomain || {};\n    result.contextDomain = { ...anchorContextDomains, ...result.contextDomain };\n    delete result.contextDomainAnchor;\n  }\n\n  if (result.contextDomain) {\n    const resolvedContextDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.contextDomain)) {\n      if (typeof value === \"string\") {\n        resolvedContextDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for contextDomain key \"${key}\"`);\n\n        if (!anchorSpec.contextDomain || anchorSpec.contextDomain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Context domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedContextDomain[key] = anchorSpec.contextDomain[key];\n      }\n    }\n    result.contextDomain = resolvedContextDomain;\n  }\n\n  if (result.axes) result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));\n\n  return result as PColumnSelector;\n}\n\n/**\n * Resolves an anchored axis reference to a concrete AxisId\n */\nfunction resolveAxisReference(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\">>,\n  axisRef: AAxisSelector,\n): LegacyAxisSelector {\n  if (!isAnchorAxisRef(axisRef)) return axisRef;\n\n  // It's an anchored reference\n  const anchorId = axisRef.anchor;\n  const anchorSpec = anchors[anchorId];\n  if (!anchorSpec) throw new Error(`Anchor \"${anchorId}\" not found for axis reference`);\n\n  if (\"idx\" in axisRef) {\n    // AnchorAxisRefByIdx\n    if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)\n      throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor \"${anchorId}\"`);\n    return anchorSpec.axesSpec[axisRef.idx];\n  } else if (\"name\" in axisRef) {\n    // AnchorAxisRefByName\n    const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);\n    if (matches.length > 1)\n      throw new Error(`Multiple axes with name \"${axisRef.name}\" found in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`Axis with name \"${axisRef.name}\" not found in anchor \"${anchorId}\"`);\n    return matches[0];\n  } else if (\"id\" in axisRef) {\n    // AnchorAxisRefByMatcher\n    const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));\n    if (matches.length > 1)\n      throw new Error(`Multiple matching axes found for matcher in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`No matching axis found for matcher in anchor \"${anchorId}\"`);\n    return matches[0];\n  }\n\n  throw new Error(`Unsupported axis reference type`);\n}\n\n/**\n * Type guard to check if a value is an anchored axis reference\n */\nfunction isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {\n  return typeof value === \"object\" && \"anchor\" in value;\n}\n"],"mappings":"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"}
+{"version":3,"file":"anchored.cjs","names":["getAxisId","stringifyColumnId","matchAxisId"],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"sourcesContent":["import canonicalize from \"canonicalize\";\nimport type { AxisFilter, AxisFilterValue } from \"./filtered_column\";\nimport type { SUniversalPColumnId, UniversalPColumnId } from \"./ids\";\nimport { stringifyColumnId } from \"./ids\";\nimport type {\n  AAxisSelector,\n  AnchorAxisRef,\n  AnchorAxisRefByIdx,\n  AnchoredPColumnId,\n  AnchoredPColumnSelector,\n  LegacyAxisSelector,\n  PColumnSelector,\n} from \"./selectors\";\nimport type { AxisId, PColumnSpec } from \"./spec\";\nimport { getAxisId, matchAxisId } from \"./spec\";\n\n//\n// Helper functions\n//\n\nfunction axisKey(axis: AxisId): string {\n  return canonicalize(getAxisId(axis))!;\n}\n\nfunction domainKey(key: string, value: string): string {\n  return JSON.stringify([key, value]);\n}\n\n/**\n * Context for resolving and generating anchored references to columns and axes\n * Maintains maps of known domain values and axes that can be referenced by anchors\n */\nexport class AnchoredIdDeriver {\n  private readonly axes = new Map<string, AnchorAxisRefByIdx>();\n  private readonly domains = new Map<string, string>();\n  private readonly contextDomains = new Map<string, string>();\n  /**\n   * Domain packs are used to group domain keys that can be anchored to the same anchor\n   * This is used to optimize the lookup of domain anchors\n   */\n  private readonly domainPacks: string[][] = [];\n  private readonly contextDomainPacks: string[][] = [];\n  /**\n   * Maps domain packs to anchors\n   */\n  private readonly domainPackToAnchor = new Map<string, string>();\n  private readonly contextDomainPackToAnchor = new Map<string, string>();\n\n  /**\n   * Creates a new anchor context from a set of anchor column specifications\n   * @param anchors Record of anchor column specifications indexed by anchor ID\n   */\n  constructor(\n    public readonly anchors: Record<\n      string,\n      Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">\n    >,\n  ) {\n    const anchorEntries = Object.entries(anchors);\n    anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));\n    for (const [anchorId, spec] of anchorEntries) {\n      for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {\n        const axis = spec.axesSpec[axisIdx];\n        const key = axisKey(axis);\n        this.axes.set(key, { anchor: anchorId, idx: axisIdx });\n      }\n      if (spec.domain !== undefined) {\n        const domainEntries = Object.entries(spec.domain);\n        domainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);\n        this.domainPacks.push(domainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of domainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.domains.set(key, anchorId);\n        }\n      }\n      if (spec.contextDomain !== undefined) {\n        const contextDomainEntries = Object.entries(spec.contextDomain);\n        contextDomainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.contextDomainPackToAnchor.set(JSON.stringify(contextDomainEntries), anchorId);\n        this.contextDomainPacks.push(contextDomainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of contextDomainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.contextDomains.set(key, anchorId);\n        }\n      }\n    }\n  }\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @returns An anchored column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec): AnchoredPColumnId;\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @param axisFilters Axis filters to apply to the column\n   * @returns An anchored and sliced column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId;\n\n  /**\n   * Implementation of derive method\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId {\n    const result: AnchoredPColumnId = {\n      name: spec.name,\n      axes: [],\n    };\n\n    let skipDomains: Set<string> | undefined = undefined;\n    if (spec.domain !== undefined) {\n      outer: for (const domainPack of this.domainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of domainPack) {\n          const dValue = spec.domain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (domainAnchor !== undefined) {\n          result.domainAnchor = domainAnchor;\n          skipDomains = new Set(domainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {\n      if (skipDomains !== undefined && skipDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.domains.get(key);\n      result.domain ??= {};\n      result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    let skipContextDomains: Set<string> | undefined = undefined;\n    if (spec.contextDomain !== undefined) {\n      outer: for (const contextDomainPack of this.contextDomainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of contextDomainPack) {\n          const dValue = spec.contextDomain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const contextDomainAnchor = this.contextDomainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (contextDomainAnchor !== undefined) {\n          result.contextDomainAnchor = contextDomainAnchor;\n          skipContextDomains = new Set(contextDomainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.contextDomain ?? {})) {\n      if (skipContextDomains !== undefined && skipContextDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.contextDomains.get(key);\n      result.contextDomain ??= {};\n      result.contextDomain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    result.axes = spec.axesSpec.map((axis) => {\n      const key = axisKey(axis);\n      const anchorAxisRef = this.axes.get(key);\n      if (anchorAxisRef === undefined) return getAxisId(axis);\n      else return anchorAxisRef;\n    });\n\n    // If no axis filters are provided, return the anchored ID as is\n    if (!axisFilters || axisFilters.length === 0) {\n      return result;\n    }\n\n    // Process axis filters and create a sliced column ID\n    const resolvedFilters: [number, AxisFilterValue][] = [];\n\n    for (const filter of axisFilters) {\n      const [axisIdOrIndex, value] = filter;\n\n      // If it's already a numeric index, validate it\n      if (typeof axisIdOrIndex === \"number\") {\n        if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {\n          throw new Error(\n            `Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`,\n          );\n        }\n        resolvedFilters.push([axisIdOrIndex, value]);\n      } else {\n        // If it's a string (axis name), resolve it to an index\n        const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);\n        if (axisIndex === -1) {\n          throw new Error(\n            `Axis with name \"${axisIdOrIndex}\" not found in the column specification`,\n          );\n        }\n        resolvedFilters.push([axisIndex, value]);\n      }\n    }\n\n    // Sort filters by axis index to ensure consistency\n    resolvedFilters.sort((a, b) => a[0] - b[0]);\n\n    return {\n      source: result,\n      axisFilters: resolvedFilters,\n    };\n  }\n\n  /**\n   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column\n   * @param spec Column specification to anchor\n   * @param axisFilters Optional axis filters to apply to the column\n   * @returns A canonicalized string representation of the anchored column identifier\n   */\n  deriveS(spec: PColumnSpec, axisFilters?: AxisFilter[]): SUniversalPColumnId {\n    return stringifyColumnId(this.derive(spec, axisFilters));\n  }\n}\n\n/**\n * Options for the resolveAnchors function\n */\nexport type ResolveAnchorsOptions = {\n  /**\n   * If true, missing domain keys in anchors will be ignored.\n   * If false (default), an error will be thrown.\n   */\n  ignoreMissingDomains?: boolean;\n};\n\n/**\n * Resolves anchored references in a column matcher to create a non-anchored matcher.\n * Doing an opposite operation to {@link AnchorIdDeriver.derive()}.\n *\n * @param anchors - Record of anchor column specifications indexed by anchor id\n * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved\n * @param options - Options for resolving anchors\n * @returns A non-anchored column matcher with all references resolved to actual values\n * @deprecated - This function by parent PColumnCollection\n */\nexport function resolveAnchors(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">>,\n  matcher: AnchoredPColumnSelector,\n  options?: ResolveAnchorsOptions,\n): PColumnSelector {\n  const result = { ...matcher };\n  const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;\n\n  if (result.domainAnchor !== undefined) {\n    const anchorSpec = anchors[result.domainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.domainAnchor}\" not found`);\n\n    const anchorDomains = anchorSpec.domain || {};\n    result.domain = { ...anchorDomains, ...result.domain };\n    delete result.domainAnchor;\n  }\n\n  if (result.domain) {\n    const resolvedDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.domain)) {\n      if (typeof value === \"string\") {\n        resolvedDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for domain key \"${key}\"`);\n\n        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedDomain[key] = anchorSpec.domain[key];\n      }\n    }\n    result.domain = resolvedDomain;\n  }\n\n  if (result.contextDomainAnchor !== undefined) {\n    const anchorSpec = anchors[result.contextDomainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.contextDomainAnchor}\" not found`);\n\n    const anchorContextDomains = anchorSpec.contextDomain || {};\n    result.contextDomain = { ...anchorContextDomains, ...result.contextDomain };\n    delete result.contextDomainAnchor;\n  }\n\n  if (result.contextDomain) {\n    const resolvedContextDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.contextDomain)) {\n      if (typeof value === \"string\") {\n        resolvedContextDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for contextDomain key \"${key}\"`);\n\n        if (!anchorSpec.contextDomain || anchorSpec.contextDomain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Context domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedContextDomain[key] = anchorSpec.contextDomain[key];\n      }\n    }\n    result.contextDomain = resolvedContextDomain;\n  }\n\n  if (result.axes) result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));\n\n  return result as PColumnSelector;\n}\n\n/**\n * Resolves an anchored axis reference to a concrete AxisId\n */\nfunction resolveAxisReference(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\">>,\n  axisRef: AAxisSelector,\n): LegacyAxisSelector {\n  if (!isAnchorAxisRef(axisRef)) return axisRef;\n\n  // It's an anchored reference\n  const anchorId = axisRef.anchor;\n  const anchorSpec = anchors[anchorId];\n  if (!anchorSpec) throw new Error(`Anchor \"${anchorId}\" not found for axis reference`);\n\n  if (\"idx\" in axisRef) {\n    // AnchorAxisRefByIdx\n    if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)\n      throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor \"${anchorId}\"`);\n    return anchorSpec.axesSpec[axisRef.idx];\n  } else if (\"name\" in axisRef) {\n    // AnchorAxisRefByName\n    const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);\n    if (matches.length > 1)\n      throw new Error(`Multiple axes with name \"${axisRef.name}\" found in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`Axis with name \"${axisRef.name}\" not found in anchor \"${anchorId}\"`);\n    return matches[0];\n  } else if (\"id\" in axisRef) {\n    // AnchorAxisRefByMatcher\n    const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));\n    if (matches.length > 1)\n      throw new Error(`Multiple matching axes found for matcher in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`No matching axis found for matcher in anchor \"${anchorId}\"`);\n    return matches[0];\n  }\n\n  throw new Error(`Unsupported axis reference type`);\n}\n\n/**\n * Type guard to check if a value is an anchored axis reference\n */\nfunction isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {\n  return typeof value === \"object\" && \"anchor\" in value;\n}\n"],"mappings":";;;;;;AAoBA,SAAS,QAAQ,MAAsB;CACrC,QAAA,GAAA,aAAA,QAAA,CAAoBA,aAAAA,UAAU,IAAI,CAAC;AACrC;AAEA,SAAS,UAAU,KAAa,OAAuB;CACrD,OAAO,KAAK,UAAU,CAAC,KAAK,KAAK,CAAC;AACpC;;;;;AAMA,IAAa,oBAAb,MAA+B;CAqBX;CApBlB,uBAAwB,IAAI,IAAgC;CAC5D,0BAA2B,IAAI,IAAoB;CACnD,iCAAkC,IAAI,IAAoB;;;;;CAK1D,cAA2C,CAAC;CAC5C,qBAAkD,CAAC;;;;CAInD,qCAAsC,IAAI,IAAoB;CAC9D,4CAA6C,IAAI,IAAoB;;;;;CAMrE,YACE,SAIA;EAJgB,KAAA,UAAA;EAKhB,MAAM,gBAAgB,OAAO,QAAQ,OAAO;EAC5C,cAAc,MAAM,GAAG,MAAM,EAAE,EAAE,CAAC,cAAc,EAAE,EAAE,CAAC;EACrD,KAAK,MAAM,CAAC,UAAU,SAAS,eAAe;GAC5C,KAAK,IAAI,UAAU,GAAG,UAAU,KAAK,SAAS,QAAQ,WAAW;IAC/D,MAAM,OAAO,KAAK,SAAS;IAC3B,MAAM,MAAM,QAAQ,IAAI;IACxB,KAAK,KAAK,IAAI,KAAK;KAAE,QAAQ;KAAU,KAAK;IAAQ,CAAC;GACvD;GACA,IAAI,KAAK,WAAW,KAAA,GAAW;IAC7B,MAAM,gBAAgB,OAAO,QAAQ,KAAK,MAAM;IAChD,cAAc,MAAM,GAAG,MAAM,EAAE,EAAE,CAAC,cAAc,EAAE,EAAE,CAAC;IAErD,KAAK,mBAAmB,IAAI,KAAK,UAAU,aAAa,GAAG,QAAQ;IACnE,KAAK,YAAY,KAAK,cAAc,KAAK,CAAC,UAAU,IAAI,CAAC;IAEzD,KAAK,MAAM,CAAC,MAAM,WAAW,eAAe;KAC1C,MAAM,MAAM,UAAU,MAAM,MAAM;KAClC,KAAK,QAAQ,IAAI,KAAK,QAAQ;IAChC;GACF;GACA,IAAI,KAAK,kBAAkB,KAAA,GAAW;IACpC,MAAM,uBAAuB,OAAO,QAAQ,KAAK,aAAa;IAC9D,qBAAqB,MAAM,GAAG,MAAM,EAAE,EAAE,CAAC,cAAc,EAAE,EAAE,CAAC;IAE5D,KAAK,0BAA0B,IAAI,KAAK,UAAU,oBAAoB,GAAG,QAAQ;IACjF,KAAK,mBAAmB,KAAK,qBAAqB,KAAK,CAAC,UAAU,IAAI,CAAC;IAEvE,KAAK,MAAM,CAAC,MAAM,WAAW,sBAAsB;KACjD,MAAM,MAAM,UAAU,MAAM,MAAM;KAClC,KAAK,eAAe,IAAI,KAAK,QAAQ;IACvC;GACF;EACF;CACF;;;;CAoBA,OAAO,MAAmB,aAAgD;EACxE,MAAM,SAA4B;GAChC,MAAM,KAAK;GACX,MAAM,CAAC;EACT;EAEA,IAAI,cAAuC,KAAA;EAC3C,IAAI,KAAK,WAAW,KAAA,GAClB,OAAO,KAAK,MAAM,cAAc,KAAK,aAAa;GAChD,MAAM,UAAsB,CAAC;GAC7B,KAAK,MAAM,aAAa,YAAY;IAClC,MAAM,SAAS,KAAK,OAAO;IAC3B,IAAI,WAAW,KAAA,GAAW,QAAQ,KAAK,CAAC,WAAW,MAAM,CAAC;SACrD,MAAM;GACb;GACA,MAAM,eAAe,KAAK,mBAAmB,IAAI,KAAK,UAAU,OAAO,CAAC;GACxE,IAAI,iBAAiB,KAAA,GAAW;IAC9B,OAAO,eAAe;IACtB,cAAc,IAAI,IAAI,UAAU;IAChC;GACF;EACF;EAGF,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,GAAG;GAC9D,IAAI,gBAAgB,KAAA,KAAa,YAAY,IAAI,IAAI,GAAG;GACxD,MAAM,MAAM,UAAU,MAAM,MAAM;GAClC,MAAM,WAAW,KAAK,QAAQ,IAAI,GAAG;GACrC,OAAO,WAAW,CAAC;GACnB,OAAO,OAAO,QAAQ,WAAW,EAAE,QAAQ,SAAS,IAAI;EAC1D;EAEA,IAAI,qBAA8C,KAAA;EAClD,IAAI,KAAK,kBAAkB,KAAA,GACzB,OAAO,KAAK,MAAM,qBAAqB,KAAK,oBAAoB;GAC9D,MAAM,UAAsB,CAAC;GAC7B,KAAK,MAAM,aAAa,mBAAmB;IACzC,MAAM,SAAS,KAAK,cAAc;IAClC,IAAI,WAAW,KAAA,GAAW,QAAQ,KAAK,CAAC,WAAW,MAAM,CAAC;SACrD,MAAM;GACb;GACA,MAAM,sBAAsB,KAAK,0BAA0B,IAAI,KAAK,UAAU,OAAO,CAAC;GACtF,IAAI,wBAAwB,KAAA,GAAW;IACrC,OAAO,sBAAsB;IAC7B,qBAAqB,IAAI,IAAI,iBAAiB;IAC9C;GACF;EACF;EAGF,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,KAAK,iBAAiB,CAAC,CAAC,GAAG;GACrE,IAAI,uBAAuB,KAAA,KAAa,mBAAmB,IAAI,IAAI,GAAG;GACtE,MAAM,MAAM,UAAU,MAAM,MAAM;GAClC,MAAM,WAAW,KAAK,eAAe,IAAI,GAAG;GAC5C,OAAO,kBAAkB,CAAC;GAC1B,OAAO,cAAc,QAAQ,WAAW,EAAE,QAAQ,SAAS,IAAI;EACjE;EAEA,OAAO,OAAO,KAAK,SAAS,KAAK,SAAS;GACxC,MAAM,MAAM,QAAQ,IAAI;GACxB,MAAM,gBAAgB,KAAK,KAAK,IAAI,GAAG;GACvC,IAAI,kBAAkB,KAAA,GAAW,OAAOA,aAAAA,UAAU,IAAI;QACjD,OAAO;EACd,CAAC;EAGD,IAAI,CAAC,eAAe,YAAY,WAAW,GACzC,OAAO;EAIT,MAAM,kBAA+C,CAAC;EAEtD,KAAK,MAAM,UAAU,aAAa;GAChC,MAAM,CAAC,eAAe,SAAS;GAG/B,IAAI,OAAO,kBAAkB,UAAU;IACrC,IAAI,gBAAgB,KAAK,iBAAiB,KAAK,SAAS,QACtD,MAAM,IAAI,MACR,cAAc,cAAc,uBAAuB,KAAK,SAAS,SAAS,EAAE,EAC9E;IAEF,gBAAgB,KAAK,CAAC,eAAe,KAAK,CAAC;GAC7C,OAAO;IAEL,MAAM,YAAY,KAAK,SAAS,WAAW,SAAS,KAAK,SAAS,aAAa;IAC/E,IAAI,cAAc,IAChB,MAAM,IAAI,MACR,mBAAmB,cAAc,wCACnC;IAEF,gBAAgB,KAAK,CAAC,WAAW,KAAK,CAAC;GACzC;EACF;EAGA,gBAAgB,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE;EAE1C,OAAO;GACL,QAAQ;GACR,aAAa;EACf;CACF;;;;;;;CAQA,QAAQ,MAAmB,aAAiD;EAC1E,OAAOC,YAAAA,kBAAkB,KAAK,OAAO,MAAM,WAAW,CAAC;CACzD;AACF;;;;;;;;;;;AAuBA,SAAgB,eACd,SACA,SACA,SACiB;CACjB,MAAM,SAAS,EAAE,GAAG,QAAQ;CAC5B,MAAM,uBAAuB,SAAS,wBAAwB;CAE9D,IAAI,OAAO,iBAAiB,KAAA,GAAW;EACrC,MAAM,aAAa,QAAQ,OAAO;EAClC,IAAI,CAAC,YAAY,MAAM,IAAI,MAAM,WAAW,OAAO,aAAa,YAAY;EAG5E,OAAO,SAAS;GAAE,GADI,WAAW,UAAU,CAAC;GACR,GAAG,OAAO;EAAO;EACrD,OAAO,OAAO;CAChB;CAEA,IAAI,OAAO,QAAQ;EACjB,MAAM,iBAAyC,CAAC;EAChD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,MAAM,GACrD,IAAI,OAAO,UAAU,UACnB,eAAe,OAAO;OACjB;GAEL,MAAM,aAAa,QAAQ,MAAM;GACjC,IAAI,CAAC,YACH,MAAM,IAAI,MAAM,WAAW,MAAM,OAAO,8BAA8B,IAAI,EAAE;GAE9E,IAAI,CAAC,WAAW,UAAU,WAAW,OAAO,SAAS,KAAA,GAAW;IAC9D,IAAI,CAAC,sBACH,MAAM,IAAI,MAAM,eAAe,IAAI,yBAAyB,MAAM,OAAO,EAAE;IAC7E;GACF;GAEA,eAAe,OAAO,WAAW,OAAO;EAC1C;EAEF,OAAO,SAAS;CAClB;CAEA,IAAI,OAAO,wBAAwB,KAAA,GAAW;EAC5C,MAAM,aAAa,QAAQ,OAAO;EAClC,IAAI,CAAC,YAAY,MAAM,IAAI,MAAM,WAAW,OAAO,oBAAoB,YAAY;EAGnF,OAAO,gBAAgB;GAAE,GADI,WAAW,iBAAiB,CAAC;GACR,GAAG,OAAO;EAAc;EAC1E,OAAO,OAAO;CAChB;CAEA,IAAI,OAAO,eAAe;EACxB,MAAM,wBAAgD,CAAC;EACvD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,aAAa,GAC5D,IAAI,OAAO,UAAU,UACnB,sBAAsB,OAAO;OACxB;GAEL,MAAM,aAAa,QAAQ,MAAM;GACjC,IAAI,CAAC,YACH,MAAM,IAAI,MAAM,WAAW,MAAM,OAAO,qCAAqC,IAAI,EAAE;GAErF,IAAI,CAAC,WAAW,iBAAiB,WAAW,cAAc,SAAS,KAAA,GAAW;IAC5E,IAAI,CAAC,sBACH,MAAM,IAAI,MAAM,uBAAuB,IAAI,yBAAyB,MAAM,OAAO,EAAE;IACrF;GACF;GAEA,sBAAsB,OAAO,WAAW,cAAc;EACxD;EAEF,OAAO,gBAAgB;CACzB;CAEA,IAAI,OAAO,MAAM,OAAO,OAAO,OAAO,KAAK,KAAK,SAAS,qBAAqB,SAAS,IAAI,CAAC;CAE5F,OAAO;AACT;;;;AAKA,SAAS,qBACP,SACA,SACoB;CACpB,IAAI,CAAC,gBAAgB,OAAO,GAAG,OAAO;CAGtC,MAAM,WAAW,QAAQ;CACzB,MAAM,aAAa,QAAQ;CAC3B,IAAI,CAAC,YAAY,MAAM,IAAI,MAAM,WAAW,SAAS,+BAA+B;CAEpF,IAAI,SAAS,SAAS;EAEpB,IAAI,QAAQ,MAAM,KAAK,QAAQ,OAAO,WAAW,SAAS,QACxD,MAAM,IAAI,MAAM,cAAc,QAAQ,IAAI,6BAA6B,SAAS,EAAE;EACpF,OAAO,WAAW,SAAS,QAAQ;CACrC,OAAO,IAAI,UAAU,SAAS;EAE5B,MAAM,UAAU,WAAW,SAAS,QAAQ,SAAS,KAAK,SAAS,QAAQ,IAAI;EAC/E,IAAI,QAAQ,SAAS,GACnB,MAAM,IAAI,MAAM,4BAA4B,QAAQ,KAAK,qBAAqB,SAAS,EAAE;EAC3F,IAAI,QAAQ,WAAW,GACrB,MAAM,IAAI,MAAM,mBAAmB,QAAQ,KAAK,yBAAyB,SAAS,EAAE;EACtF,OAAO,QAAQ;CACjB,OAAO,IAAI,QAAQ,SAAS;EAE1B,MAAM,UAAU,WAAW,SAAS,QAAQ,SAASC,aAAAA,YAAY,QAAQ,IAAIF,aAAAA,UAAU,IAAI,CAAC,CAAC;EAC7F,IAAI,QAAQ,SAAS,GACnB,MAAM,IAAI,MAAM,uDAAuD,SAAS,EAAE;EACpF,IAAI,QAAQ,WAAW,GACrB,MAAM,IAAI,MAAM,iDAAiD,SAAS,EAAE;EAC9E,OAAO,QAAQ;CACjB;CAEA,MAAM,IAAI,MAAM,iCAAiC;AACnD;;;;AAKA,SAAS,gBAAgB,OAA8C;CACrE,OAAO,OAAO,UAAU,YAAY,YAAY;AAClD"}

package/dist/drivers/pframe/spec/anchored.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anchored.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"mappings":";;;;;;;;AAgCA;;cAAa,iBAAA;EAAA,SAqBO,OAAA,EAAS,MAAA,SAEvB,IAAA,CAAK,WAAA;EAAA,iBAtBQ,IAAA;EAAA,iBACA,OAAA;EAAA,iBACA,cAAA;EAoBb;;;;EAAA,iBAfa,WAAA;EAAA,iBACA,kBAAA;EAiEsC;;;EAAA,iBA7DtC,kBAAA;EAAA,iBACA,yBAAA;EAgL0D;;;;cAzKzD,OAAA,EAAS,MAAA,SAEvB,IAAA,CAAK,WAAA;EAtBQ;;;;;EAiEjB,MAAA,CAAO,IAAA,EAAM,WAAA,GAAc,iBAAA;EApDV;;;;;;EA4DjB,MAAA,CAAO,IAAA,EAAM,WAAA,EAAa,WAAA,GAAc,UAAA,KAAe,kBAAA;EAR1C;;;;;;EA4Hb,OAAA,CAAQ,IAAA,EAAM,WAAA,EAAa,WAAA,GAAc,UAAA,KAAe,mBAAA;AAAA;;;;KAQ9C,qBAAA;EAR+B;;;;EAazC,oBAAA;AAAA;;;;;AAaF;;;;;;iBAAgB,cAAA,CACd,OAAA,EAAS,MAAA,SAAe,IAAA,CAAK,WAAA,6CAC7B,OAAA,EAAS,uBAAA,EACT,OAAA,GAAU,qBAAA,GACT,eAAA"}
+{"version":3,"file":"anchored.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"mappings":";;;;;;;;AAgCA;;cAAa,iBAAA;EAAA,SAqBO,OAAA,EAAS,MAAA,SAEvB,IAAA,CAAK,WAAA;EAAA,iBAtBQ,IAAA;EAAA,iBACA,OAAA;EAAA,iBACA,cAAA;EAoBb;;;;EAAA,iBAfa,WAAA;EAAA,iBACA,kBAAA;EAiEsC;;;EAAA,iBA7DtC,kBAAA;EAAA,iBACA,yBAAA;EAgL0D;;;;cAzKzD,OAAA,EAAS,MAAA,SAEvB,IAAA,CAAK,WAAA;EAtBQ;;;;;EAiEjB,MAAA,CAAO,IAAA,EAAM,WAAA,GAAc,iBAAA;EApDV;;;;;;EA4DjB,MAAA,CAAO,IAAA,EAAM,WAAA,EAAa,WAAA,GAAc,UAAA,KAAe,kBAAA;EAR1C;;;;;;EA4Hb,OAAA,CAAQ,IAAA,EAAM,WAAA,EAAa,WAAA,GAAc,UAAA,KAAe,mBAAA;AAAA;;;;KAQ9C,qBAAA;EAR+B;;;;EAazC,oBAAoB;AAAA;;;;AAAA;AAatB;;;;;;iBAAgB,cAAA,CACd,OAAA,EAAS,MAAA,SAAe,IAAA,CAAK,WAAA,6CAC7B,OAAA,EAAS,uBAAA,EACT,OAAA,GAAU,qBAAA,GACT,eAAA"}

package/dist/drivers/pframe/spec/anchored.js

@@ -13,6 +13,7 @@ function domainKey(key, value) {
 * Maintains maps of known domain values and axes that can be referenced by anchors
 */
 var AnchoredIdDeriver = class {
+	anchors;
 	axes = /* @__PURE__ */ new Map();
 	domains = /* @__PURE__ */ new Map();
 	contextDomains = /* @__PURE__ */ new Map();

package/dist/drivers/pframe/spec/anchored.js.map

@@ -1 +1 @@
-{"version":3,"file":"anchored.js","names":[],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"sourcesContent":["import canonicalize from \"canonicalize\";\nimport type { AxisFilter, AxisFilterValue } from \"./filtered_column\";\nimport type { SUniversalPColumnId, UniversalPColumnId } from \"./ids\";\nimport { stringifyColumnId } from \"./ids\";\nimport type {\n  AAxisSelector,\n  AnchorAxisRef,\n  AnchorAxisRefByIdx,\n  AnchoredPColumnId,\n  AnchoredPColumnSelector,\n  LegacyAxisSelector,\n  PColumnSelector,\n} from \"./selectors\";\nimport type { AxisId, PColumnSpec } from \"./spec\";\nimport { getAxisId, matchAxisId } from \"./spec\";\n\n//\n// Helper functions\n//\n\nfunction axisKey(axis: AxisId): string {\n  return canonicalize(getAxisId(axis))!;\n}\n\nfunction domainKey(key: string, value: string): string {\n  return JSON.stringify([key, value]);\n}\n\n/**\n * Context for resolving and generating anchored references to columns and axes\n * Maintains maps of known domain values and axes that can be referenced by anchors\n */\nexport class AnchoredIdDeriver {\n  private readonly axes = new Map<string, AnchorAxisRefByIdx>();\n  private readonly domains = new Map<string, string>();\n  private readonly contextDomains = new Map<string, string>();\n  /**\n   * Domain packs are used to group domain keys that can be anchored to the same anchor\n   * This is used to optimize the lookup of domain anchors\n   */\n  private readonly domainPacks: string[][] = [];\n  private readonly contextDomainPacks: string[][] = [];\n  /**\n   * Maps domain packs to anchors\n   */\n  private readonly domainPackToAnchor = new Map<string, string>();\n  private readonly contextDomainPackToAnchor = new Map<string, string>();\n\n  /**\n   * Creates a new anchor context from a set of anchor column specifications\n   * @param anchors Record of anchor column specifications indexed by anchor ID\n   */\n  constructor(\n    public readonly anchors: Record<\n      string,\n      Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">\n    >,\n  ) {\n    const anchorEntries = Object.entries(anchors);\n    anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));\n    for (const [anchorId, spec] of anchorEntries) {\n      for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {\n        const axis = spec.axesSpec[axisIdx];\n        const key = axisKey(axis);\n        this.axes.set(key, { anchor: anchorId, idx: axisIdx });\n      }\n      if (spec.domain !== undefined) {\n        const domainEntries = Object.entries(spec.domain);\n        domainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);\n        this.domainPacks.push(domainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of domainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.domains.set(key, anchorId);\n        }\n      }\n      if (spec.contextDomain !== undefined) {\n        const contextDomainEntries = Object.entries(spec.contextDomain);\n        contextDomainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.contextDomainPackToAnchor.set(JSON.stringify(contextDomainEntries), anchorId);\n        this.contextDomainPacks.push(contextDomainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of contextDomainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.contextDomains.set(key, anchorId);\n        }\n      }\n    }\n  }\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @returns An anchored column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec): AnchoredPColumnId;\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @param axisFilters Axis filters to apply to the column\n   * @returns An anchored and sliced column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId;\n\n  /**\n   * Implementation of derive method\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId {\n    const result: AnchoredPColumnId = {\n      name: spec.name,\n      axes: [],\n    };\n\n    let skipDomains: Set<string> | undefined = undefined;\n    if (spec.domain !== undefined) {\n      outer: for (const domainPack of this.domainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of domainPack) {\n          const dValue = spec.domain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (domainAnchor !== undefined) {\n          result.domainAnchor = domainAnchor;\n          skipDomains = new Set(domainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {\n      if (skipDomains !== undefined && skipDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.domains.get(key);\n      result.domain ??= {};\n      result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    let skipContextDomains: Set<string> | undefined = undefined;\n    if (spec.contextDomain !== undefined) {\n      outer: for (const contextDomainPack of this.contextDomainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of contextDomainPack) {\n          const dValue = spec.contextDomain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const contextDomainAnchor = this.contextDomainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (contextDomainAnchor !== undefined) {\n          result.contextDomainAnchor = contextDomainAnchor;\n          skipContextDomains = new Set(contextDomainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.contextDomain ?? {})) {\n      if (skipContextDomains !== undefined && skipContextDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.contextDomains.get(key);\n      result.contextDomain ??= {};\n      result.contextDomain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    result.axes = spec.axesSpec.map((axis) => {\n      const key = axisKey(axis);\n      const anchorAxisRef = this.axes.get(key);\n      if (anchorAxisRef === undefined) return getAxisId(axis);\n      else return anchorAxisRef;\n    });\n\n    // If no axis filters are provided, return the anchored ID as is\n    if (!axisFilters || axisFilters.length === 0) {\n      return result;\n    }\n\n    // Process axis filters and create a sliced column ID\n    const resolvedFilters: [number, AxisFilterValue][] = [];\n\n    for (const filter of axisFilters) {\n      const [axisIdOrIndex, value] = filter;\n\n      // If it's already a numeric index, validate it\n      if (typeof axisIdOrIndex === \"number\") {\n        if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {\n          throw new Error(\n            `Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`,\n          );\n        }\n        resolvedFilters.push([axisIdOrIndex, value]);\n      } else {\n        // If it's a string (axis name), resolve it to an index\n        const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);\n        if (axisIndex === -1) {\n          throw new Error(\n            `Axis with name \"${axisIdOrIndex}\" not found in the column specification`,\n          );\n        }\n        resolvedFilters.push([axisIndex, value]);\n      }\n    }\n\n    // Sort filters by axis index to ensure consistency\n    resolvedFilters.sort((a, b) => a[0] - b[0]);\n\n    return {\n      source: result,\n      axisFilters: resolvedFilters,\n    };\n  }\n\n  /**\n   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column\n   * @param spec Column specification to anchor\n   * @param axisFilters Optional axis filters to apply to the column\n   * @returns A canonicalized string representation of the anchored column identifier\n   */\n  deriveS(spec: PColumnSpec, axisFilters?: AxisFilter[]): SUniversalPColumnId {\n    return stringifyColumnId(this.derive(spec, axisFilters));\n  }\n}\n\n/**\n * Options for the resolveAnchors function\n */\nexport type ResolveAnchorsOptions = {\n  /**\n   * If true, missing domain keys in anchors will be ignored.\n   * If false (default), an error will be thrown.\n   */\n  ignoreMissingDomains?: boolean;\n};\n\n/**\n * Resolves anchored references in a column matcher to create a non-anchored matcher.\n * Doing an opposite operation to {@link AnchorIdDeriver.derive()}.\n *\n * @param anchors - Record of anchor column specifications indexed by anchor id\n * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved\n * @param options - Options for resolving anchors\n * @returns A non-anchored column matcher with all references resolved to actual values\n * @deprecated - This function by parent PColumnCollection\n */\nexport function resolveAnchors(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">>,\n  matcher: AnchoredPColumnSelector,\n  options?: ResolveAnchorsOptions,\n): PColumnSelector {\n  const result = { ...matcher };\n  const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;\n\n  if (result.domainAnchor !== undefined) {\n    const anchorSpec = anchors[result.domainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.domainAnchor}\" not found`);\n\n    const anchorDomains = anchorSpec.domain || {};\n    result.domain = { ...anchorDomains, ...result.domain };\n    delete result.domainAnchor;\n  }\n\n  if (result.domain) {\n    const resolvedDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.domain)) {\n      if (typeof value === \"string\") {\n        resolvedDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for domain key \"${key}\"`);\n\n        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedDomain[key] = anchorSpec.domain[key];\n      }\n    }\n    result.domain = resolvedDomain;\n  }\n\n  if (result.contextDomainAnchor !== undefined) {\n    const anchorSpec = anchors[result.contextDomainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.contextDomainAnchor}\" not found`);\n\n    const anchorContextDomains = anchorSpec.contextDomain || {};\n    result.contextDomain = { ...anchorContextDomains, ...result.contextDomain };\n    delete result.contextDomainAnchor;\n  }\n\n  if (result.contextDomain) {\n    const resolvedContextDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.contextDomain)) {\n      if (typeof value === \"string\") {\n        resolvedContextDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for contextDomain key \"${key}\"`);\n\n        if (!anchorSpec.contextDomain || anchorSpec.contextDomain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Context domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedContextDomain[key] = anchorSpec.contextDomain[key];\n      }\n    }\n    result.contextDomain = resolvedContextDomain;\n  }\n\n  if (result.axes) result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));\n\n  return result as PColumnSelector;\n}\n\n/**\n * Resolves an anchored axis reference to a concrete AxisId\n */\nfunction resolveAxisReference(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\">>,\n  axisRef: AAxisSelector,\n): LegacyAxisSelector {\n  if (!isAnchorAxisRef(axisRef)) return axisRef;\n\n  // It's an anchored reference\n  const anchorId = axisRef.anchor;\n  const anchorSpec = anchors[anchorId];\n  if (!anchorSpec) throw new Error(`Anchor \"${anchorId}\" not found for axis reference`);\n\n  if (\"idx\" in axisRef) {\n    // AnchorAxisRefByIdx\n    if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)\n      throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor \"${anchorId}\"`);\n    return anchorSpec.axesSpec[axisRef.idx];\n  } else if (\"name\" in axisRef) {\n    // AnchorAxisRefByName\n    const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);\n    if (matches.length > 1)\n      throw new Error(`Multiple axes with name \"${axisRef.name}\" found in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`Axis with name \"${axisRef.name}\" not found in anchor \"${anchorId}\"`);\n    return matches[0];\n  } else if (\"id\" in axisRef) {\n    // AnchorAxisRefByMatcher\n    const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));\n    if (matches.length > 1)\n      throw new Error(`Multiple matching axes found for matcher in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`No matching axis found for matcher in anchor \"${anchorId}\"`);\n    return matches[0];\n  }\n\n  throw new Error(`Unsupported axis reference type`);\n}\n\n/**\n * Type guard to check if a value is an anchored axis reference\n */\nfunction isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {\n  return typeof value === \"object\" && \"anchor\" in value;\n}\n"],"mappings":"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"}
+{"version":3,"file":"anchored.js","names":[],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"sourcesContent":["import canonicalize from \"canonicalize\";\nimport type { AxisFilter, AxisFilterValue } from \"./filtered_column\";\nimport type { SUniversalPColumnId, UniversalPColumnId } from \"./ids\";\nimport { stringifyColumnId } from \"./ids\";\nimport type {\n  AAxisSelector,\n  AnchorAxisRef,\n  AnchorAxisRefByIdx,\n  AnchoredPColumnId,\n  AnchoredPColumnSelector,\n  LegacyAxisSelector,\n  PColumnSelector,\n} from \"./selectors\";\nimport type { AxisId, PColumnSpec } from \"./spec\";\nimport { getAxisId, matchAxisId } from \"./spec\";\n\n//\n// Helper functions\n//\n\nfunction axisKey(axis: AxisId): string {\n  return canonicalize(getAxisId(axis))!;\n}\n\nfunction domainKey(key: string, value: string): string {\n  return JSON.stringify([key, value]);\n}\n\n/**\n * Context for resolving and generating anchored references to columns and axes\n * Maintains maps of known domain values and axes that can be referenced by anchors\n */\nexport class AnchoredIdDeriver {\n  private readonly axes = new Map<string, AnchorAxisRefByIdx>();\n  private readonly domains = new Map<string, string>();\n  private readonly contextDomains = new Map<string, string>();\n  /**\n   * Domain packs are used to group domain keys that can be anchored to the same anchor\n   * This is used to optimize the lookup of domain anchors\n   */\n  private readonly domainPacks: string[][] = [];\n  private readonly contextDomainPacks: string[][] = [];\n  /**\n   * Maps domain packs to anchors\n   */\n  private readonly domainPackToAnchor = new Map<string, string>();\n  private readonly contextDomainPackToAnchor = new Map<string, string>();\n\n  /**\n   * Creates a new anchor context from a set of anchor column specifications\n   * @param anchors Record of anchor column specifications indexed by anchor ID\n   */\n  constructor(\n    public readonly anchors: Record<\n      string,\n      Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">\n    >,\n  ) {\n    const anchorEntries = Object.entries(anchors);\n    anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));\n    for (const [anchorId, spec] of anchorEntries) {\n      for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {\n        const axis = spec.axesSpec[axisIdx];\n        const key = axisKey(axis);\n        this.axes.set(key, { anchor: anchorId, idx: axisIdx });\n      }\n      if (spec.domain !== undefined) {\n        const domainEntries = Object.entries(spec.domain);\n        domainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);\n        this.domainPacks.push(domainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of domainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.domains.set(key, anchorId);\n        }\n      }\n      if (spec.contextDomain !== undefined) {\n        const contextDomainEntries = Object.entries(spec.contextDomain);\n        contextDomainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.contextDomainPackToAnchor.set(JSON.stringify(contextDomainEntries), anchorId);\n        this.contextDomainPacks.push(contextDomainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of contextDomainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.contextDomains.set(key, anchorId);\n        }\n      }\n    }\n  }\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @returns An anchored column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec): AnchoredPColumnId;\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @param axisFilters Axis filters to apply to the column\n   * @returns An anchored and sliced column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId;\n\n  /**\n   * Implementation of derive method\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId {\n    const result: AnchoredPColumnId = {\n      name: spec.name,\n      axes: [],\n    };\n\n    let skipDomains: Set<string> | undefined = undefined;\n    if (spec.domain !== undefined) {\n      outer: for (const domainPack of this.domainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of domainPack) {\n          const dValue = spec.domain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (domainAnchor !== undefined) {\n          result.domainAnchor = domainAnchor;\n          skipDomains = new Set(domainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {\n      if (skipDomains !== undefined && skipDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.domains.get(key);\n      result.domain ??= {};\n      result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    let skipContextDomains: Set<string> | undefined = undefined;\n    if (spec.contextDomain !== undefined) {\n      outer: for (const contextDomainPack of this.contextDomainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of contextDomainPack) {\n          const dValue = spec.contextDomain[domainKey];\n          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);\n          else break outer;\n        }\n        const contextDomainAnchor = this.contextDomainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (contextDomainAnchor !== undefined) {\n          result.contextDomainAnchor = contextDomainAnchor;\n          skipContextDomains = new Set(contextDomainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.contextDomain ?? {})) {\n      if (skipContextDomains !== undefined && skipContextDomains.has(dKey)) continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.contextDomains.get(key);\n      result.contextDomain ??= {};\n      result.contextDomain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    result.axes = spec.axesSpec.map((axis) => {\n      const key = axisKey(axis);\n      const anchorAxisRef = this.axes.get(key);\n      if (anchorAxisRef === undefined) return getAxisId(axis);\n      else return anchorAxisRef;\n    });\n\n    // If no axis filters are provided, return the anchored ID as is\n    if (!axisFilters || axisFilters.length === 0) {\n      return result;\n    }\n\n    // Process axis filters and create a sliced column ID\n    const resolvedFilters: [number, AxisFilterValue][] = [];\n\n    for (const filter of axisFilters) {\n      const [axisIdOrIndex, value] = filter;\n\n      // If it's already a numeric index, validate it\n      if (typeof axisIdOrIndex === \"number\") {\n        if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {\n          throw new Error(\n            `Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`,\n          );\n        }\n        resolvedFilters.push([axisIdOrIndex, value]);\n      } else {\n        // If it's a string (axis name), resolve it to an index\n        const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);\n        if (axisIndex === -1) {\n          throw new Error(\n            `Axis with name \"${axisIdOrIndex}\" not found in the column specification`,\n          );\n        }\n        resolvedFilters.push([axisIndex, value]);\n      }\n    }\n\n    // Sort filters by axis index to ensure consistency\n    resolvedFilters.sort((a, b) => a[0] - b[0]);\n\n    return {\n      source: result,\n      axisFilters: resolvedFilters,\n    };\n  }\n\n  /**\n   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column\n   * @param spec Column specification to anchor\n   * @param axisFilters Optional axis filters to apply to the column\n   * @returns A canonicalized string representation of the anchored column identifier\n   */\n  deriveS(spec: PColumnSpec, axisFilters?: AxisFilter[]): SUniversalPColumnId {\n    return stringifyColumnId(this.derive(spec, axisFilters));\n  }\n}\n\n/**\n * Options for the resolveAnchors function\n */\nexport type ResolveAnchorsOptions = {\n  /**\n   * If true, missing domain keys in anchors will be ignored.\n   * If false (default), an error will be thrown.\n   */\n  ignoreMissingDomains?: boolean;\n};\n\n/**\n * Resolves anchored references in a column matcher to create a non-anchored matcher.\n * Doing an opposite operation to {@link AnchorIdDeriver.derive()}.\n *\n * @param anchors - Record of anchor column specifications indexed by anchor id\n * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved\n * @param options - Options for resolving anchors\n * @returns A non-anchored column matcher with all references resolved to actual values\n * @deprecated - This function by parent PColumnCollection\n */\nexport function resolveAnchors(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\" | \"domain\" | \"contextDomain\">>,\n  matcher: AnchoredPColumnSelector,\n  options?: ResolveAnchorsOptions,\n): PColumnSelector {\n  const result = { ...matcher };\n  const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;\n\n  if (result.domainAnchor !== undefined) {\n    const anchorSpec = anchors[result.domainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.domainAnchor}\" not found`);\n\n    const anchorDomains = anchorSpec.domain || {};\n    result.domain = { ...anchorDomains, ...result.domain };\n    delete result.domainAnchor;\n  }\n\n  if (result.domain) {\n    const resolvedDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.domain)) {\n      if (typeof value === \"string\") {\n        resolvedDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for domain key \"${key}\"`);\n\n        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedDomain[key] = anchorSpec.domain[key];\n      }\n    }\n    result.domain = resolvedDomain;\n  }\n\n  if (result.contextDomainAnchor !== undefined) {\n    const anchorSpec = anchors[result.contextDomainAnchor];\n    if (!anchorSpec) throw new Error(`Anchor \"${result.contextDomainAnchor}\" not found`);\n\n    const anchorContextDomains = anchorSpec.contextDomain || {};\n    result.contextDomain = { ...anchorContextDomains, ...result.contextDomain };\n    delete result.contextDomainAnchor;\n  }\n\n  if (result.contextDomain) {\n    const resolvedContextDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.contextDomain)) {\n      if (typeof value === \"string\") {\n        resolvedContextDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for contextDomain key \"${key}\"`);\n\n        if (!anchorSpec.contextDomain || anchorSpec.contextDomain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Context domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedContextDomain[key] = anchorSpec.contextDomain[key];\n      }\n    }\n    result.contextDomain = resolvedContextDomain;\n  }\n\n  if (result.axes) result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));\n\n  return result as PColumnSelector;\n}\n\n/**\n * Resolves an anchored axis reference to a concrete AxisId\n */\nfunction resolveAxisReference(\n  anchors: Record<string, Pick<PColumnSpec, \"axesSpec\">>,\n  axisRef: AAxisSelector,\n): LegacyAxisSelector {\n  if (!isAnchorAxisRef(axisRef)) return axisRef;\n\n  // It's an anchored reference\n  const anchorId = axisRef.anchor;\n  const anchorSpec = anchors[anchorId];\n  if (!anchorSpec) throw new Error(`Anchor \"${anchorId}\" not found for axis reference`);\n\n  if (\"idx\" in axisRef) {\n    // AnchorAxisRefByIdx\n    if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)\n      throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor \"${anchorId}\"`);\n    return anchorSpec.axesSpec[axisRef.idx];\n  } else if (\"name\" in axisRef) {\n    // AnchorAxisRefByName\n    const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);\n    if (matches.length > 1)\n      throw new Error(`Multiple axes with name \"${axisRef.name}\" found in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`Axis with name \"${axisRef.name}\" not found in anchor \"${anchorId}\"`);\n    return matches[0];\n  } else if (\"id\" in axisRef) {\n    // AnchorAxisRefByMatcher\n    const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));\n    if (matches.length > 1)\n      throw new Error(`Multiple matching axes found for matcher in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`No matching axis found for matcher in anchor \"${anchorId}\"`);\n    return matches[0];\n  }\n\n  throw new Error(`Unsupported axis reference type`);\n}\n\n/**\n * Type guard to check if a value is an anchored axis reference\n */\nfunction isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {\n  return typeof value === \"object\" && \"anchor\" in value;\n}\n"],"mappings":"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"}

package/dist/drivers/pframe/spec/discovered_column.cjs

@@ -1,4 +1,3 @@
-require("../../../_virtual/_rolldown/runtime.cjs");
 const require_json = require("../../../json.cjs");
 let _milaboratories_helpers = require("@milaboratories/helpers");
 //#region src/drivers/pframe/spec/discovered_column.ts

package/dist/drivers/pframe/spec/discovered_column.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"discovered_column.cjs","names":["canonicalizeJson"],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"sourcesContent":["import { Branded, throwError } from \"@milaboratories/helpers\";\nimport { PObjectId } from \"../../../pool\";\nimport { AxisQualification } from \"./selectors\";\nimport { canonicalizeJson } from \"../../../json\";\n\nexport type DiscoveredPColumn = {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n};\n\nexport type DiscoveredPColumnId = Branded<PObjectId, \"DiscoveredPColumnId\">; // CanonicalizedJson<DiscoveredPColumn>;\n\ntype PathItem = {\n  type: \"linker\";\n  column: PObjectId;\n};\n\nexport function isDiscoveredPColumn(obj: unknown): obj is DiscoveredPColumn {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"path\" in obj &&\n    \"column\" in obj &&\n    \"columnQualifications\" in obj &&\n    \"queriesQualifications\" in obj\n  );\n}\n\nexport function distillDiscoveredPColumn(props: DiscoveredPColumn): DiscoveredPColumn {\n  return {\n    column: props.column,\n    path: Array.isArray(props.path) && props.path.length > 0 ? props.path : undefined,\n    columnQualifications:\n      Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0\n        ? props.columnQualifications\n        : undefined,\n    queriesQualifications:\n      props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0\n        ? props.queriesQualifications\n        : undefined,\n  };\n}\n\nexport function createDiscoveredPColumnId(props: {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}): DiscoveredPColumnId {\n  return stringifyDiscoveredPColumnId(props);\n}\n\nexport function parseDiscoveredPColumnId(id: DiscoveredPColumnId): DiscoveredPColumn {\n  try {\n    const parsed = JSON.parse(id);\n    return isDiscoveredPColumn(parsed)\n      ? parsed\n      : throwError(\"Parsed object is not a valid DiscoveredPColumn\");\n  } catch {\n    throw new Error(\n      \"Invalid DiscoveredPColumnId: not a valid JSON or does not conform to DiscoveredPColumn structure\",\n    );\n  }\n}\n\nexport function stringifyDiscoveredPColumnId(id: DiscoveredPColumn) {\n  return canonicalizeJson<DiscoveredPColumn>(\n    distillDiscoveredPColumn(id),\n  ) as string as DiscoveredPColumnId;\n}\n"],"mappings":";;;;AAmBA,SAAgB,oBAAoB,KAAwC;AAC1E,QACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,YAAY,OACZ,0BAA0B,OAC1B,2BAA2B;;AAI/B,SAAgB,yBAAyB,OAA6C;AACpF,QAAO;EACL,QAAQ,MAAM;EACd,MAAM,MAAM,QAAQ,MAAM,KAAK,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO,KAAA;EACxE,sBACE,MAAM,QAAQ,MAAM,qBAAqB,IAAI,MAAM,qBAAqB,SAAS,IAC7E,MAAM,uBACN,KAAA;EACN,uBACE,MAAM,yBAAyB,OAAO,KAAK,MAAM,sBAAsB,CAAC,SAAS,IAC7E,MAAM,wBACN,KAAA;EACP;;AAGH,SAAgB,0BAA0B,OAKlB;AACtB,QAAO,6BAA6B,MAAM;;AAG5C,SAAgB,yBAAyB,IAA4C;AACnF,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,SAAO,oBAAoB,OAAO,GAC9B,UAAA,GAAA,wBAAA,YACW,iDAAiD;SAC1D;AACN,QAAM,IAAI,MACR,mGACD;;;AAIL,SAAgB,6BAA6B,IAAuB;AAClE,QAAOA,aAAAA,iBACL,yBAAyB,GAAG,CAC7B"}
+{"version":3,"file":"discovered_column.cjs","names":["canonicalizeJson"],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"sourcesContent":["import { Branded, throwError } from \"@milaboratories/helpers\";\nimport { PObjectId } from \"../../../pool\";\nimport { AxisQualification } from \"./selectors\";\nimport { canonicalizeJson } from \"../../../json\";\n\nexport type DiscoveredPColumn = {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n};\n\nexport type DiscoveredPColumnId = Branded<PObjectId, \"DiscoveredPColumnId\">; // CanonicalizedJson<DiscoveredPColumn>;\n\ntype PathItem = {\n  type: \"linker\";\n  column: PObjectId;\n};\n\nexport function isDiscoveredPColumn(obj: unknown): obj is DiscoveredPColumn {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"path\" in obj &&\n    \"column\" in obj &&\n    \"columnQualifications\" in obj &&\n    \"queriesQualifications\" in obj\n  );\n}\n\nexport function distillDiscoveredPColumn(props: DiscoveredPColumn): DiscoveredPColumn {\n  return {\n    column: props.column,\n    path: Array.isArray(props.path) && props.path.length > 0 ? props.path : undefined,\n    columnQualifications:\n      Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0\n        ? props.columnQualifications\n        : undefined,\n    queriesQualifications:\n      props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0\n        ? props.queriesQualifications\n        : undefined,\n  };\n}\n\nexport function createDiscoveredPColumnId(props: {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}): DiscoveredPColumnId {\n  return stringifyDiscoveredPColumnId(props);\n}\n\nexport function parseDiscoveredPColumnId(id: DiscoveredPColumnId): DiscoveredPColumn {\n  try {\n    const parsed = JSON.parse(id);\n    return isDiscoveredPColumn(parsed)\n      ? parsed\n      : throwError(\"Parsed object is not a valid DiscoveredPColumn\");\n  } catch {\n    throw new Error(\n      \"Invalid DiscoveredPColumnId: not a valid JSON or does not conform to DiscoveredPColumn structure\",\n    );\n  }\n}\n\nexport function stringifyDiscoveredPColumnId(id: DiscoveredPColumn) {\n  return canonicalizeJson<DiscoveredPColumn>(\n    distillDiscoveredPColumn(id),\n  ) as string as DiscoveredPColumnId;\n}\n"],"mappings":";;;AAmBA,SAAgB,oBAAoB,KAAwC;CAC1E,OACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,YAAY,OACZ,0BAA0B,OAC1B,2BAA2B;AAE/B;AAEA,SAAgB,yBAAyB,OAA6C;CACpF,OAAO;EACL,QAAQ,MAAM;EACd,MAAM,MAAM,QAAQ,MAAM,IAAI,KAAK,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO,KAAA;EACxE,sBACE,MAAM,QAAQ,MAAM,oBAAoB,KAAK,MAAM,qBAAqB,SAAS,IAC7E,MAAM,uBACN,KAAA;EACN,uBACE,MAAM,yBAAyB,OAAO,KAAK,MAAM,qBAAqB,CAAC,CAAC,SAAS,IAC7E,MAAM,wBACN,KAAA;CACR;AACF;AAEA,SAAgB,0BAA0B,OAKlB;CACtB,OAAO,6BAA6B,KAAK;AAC3C;AAEA,SAAgB,yBAAyB,IAA4C;CACnF,IAAI;EACF,MAAM,SAAS,KAAK,MAAM,EAAE;EAC5B,OAAO,oBAAoB,MAAM,IAC7B,UAAA,GAAA,wBAAA,WAAA,CACW,gDAAgD;CACjE,QAAQ;EACN,MAAM,IAAI,MACR,kGACF;CACF;AACF;AAEA,SAAgB,6BAA6B,IAAuB;CAClE,OAAOA,aAAAA,iBACL,yBAAyB,EAAE,CAC7B;AACF"}

package/dist/drivers/pframe/spec/discovered_column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"mappings":";;;;;KAKY,iBAAA;EACV,MAAA,EAAQ,SAAA;EACR,IAAA,GAAO,QAAA;EACP,oBAAA,GAAuB,iBAAA;EACvB,qBAAA,GAAwB,MAAA,CAAO,SAAA,EAAW,iBAAA;AAAA;AAAA,KAGhC,mBAAA,GAAsB,OAAA,CAAQ,SAAA;AAAA,KAErC,QAAA;EACH,IAAA;EACA,MAAA,EAAQ,SAAA;AAAA;AAAA,iBAGM,mBAAA,CAAoB,GAAA,YAAe,GAAA,IAAO,iBAAA;AAAA,iBAW1C,wBAAA,CAAyB,KAAA,EAAO,iBAAA,GAAoB,iBAAA;AAAA,iBAepD,yBAAA,CAA0B,KAAA;EACxC,MAAA,EAAQ,SAAA;EACR,IAAA,GAAO,QAAA;EACP,oBAAA,GAAuB,iBAAA;EACvB,qBAAA,GAAwB,MAAA,CAAO,SAAA,EAAW,iBAAA;AAAA,IACxC,mBAAA;AAAA,iBAIY,wBAAA,CAAyB,EAAA,EAAI,mBAAA,GAAsB,iBAAA;AAAA,iBAanD,4BAAA,CAA6B,EAAA,EAAI,iBAAA,GAGhC,mBAAA"}
+{"version":3,"file":"discovered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"mappings":";;;;;KAKY,iBAAA;EACV,MAAA,EAAQ,SAAA;EACR,IAAA,GAAO,QAAA;EACP,oBAAA,GAAuB,iBAAA;EACvB,qBAAA,GAAwB,MAAA,CAAO,SAAA,EAAW,iBAAA;AAAA;AAAA,KAGhC,mBAAA,GAAsB,OAAO,CAAC,SAAA;AAAA,KAErC,QAAA;EACH,IAAA;EACA,MAAA,EAAQ,SAAS;AAAA;AAAA,iBAGH,mBAAA,CAAoB,GAAA,YAAe,GAAA,IAAO,iBAAiB;AAAA,iBAW3D,wBAAA,CAAyB,KAAA,EAAO,iBAAA,GAAoB,iBAAiB;AAAA,iBAerE,yBAAA,CAA0B,KAAA;EACxC,MAAA,EAAQ,SAAA;EACR,IAAA,GAAO,QAAA;EACP,oBAAA,GAAuB,iBAAA;EACvB,qBAAA,GAAwB,MAAA,CAAO,SAAA,EAAW,iBAAA;AAAA,IACxC,mBAAA;AAAA,iBAIY,wBAAA,CAAyB,EAAA,EAAI,mBAAA,GAAsB,iBAAiB;AAAA,iBAapE,4BAAA,CAA6B,EAAA,EAAI,iBAAA,GAGhC,mBAAmB"}

package/dist/drivers/pframe/spec/discovered_column.js.map

@@ -1 +1 @@
-{"version":3,"file":"discovered_column.js","names":[],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"sourcesContent":["import { Branded, throwError } from \"@milaboratories/helpers\";\nimport { PObjectId } from \"../../../pool\";\nimport { AxisQualification } from \"./selectors\";\nimport { canonicalizeJson } from \"../../../json\";\n\nexport type DiscoveredPColumn = {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n};\n\nexport type DiscoveredPColumnId = Branded<PObjectId, \"DiscoveredPColumnId\">; // CanonicalizedJson<DiscoveredPColumn>;\n\ntype PathItem = {\n  type: \"linker\";\n  column: PObjectId;\n};\n\nexport function isDiscoveredPColumn(obj: unknown): obj is DiscoveredPColumn {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"path\" in obj &&\n    \"column\" in obj &&\n    \"columnQualifications\" in obj &&\n    \"queriesQualifications\" in obj\n  );\n}\n\nexport function distillDiscoveredPColumn(props: DiscoveredPColumn): DiscoveredPColumn {\n  return {\n    column: props.column,\n    path: Array.isArray(props.path) && props.path.length > 0 ? props.path : undefined,\n    columnQualifications:\n      Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0\n        ? props.columnQualifications\n        : undefined,\n    queriesQualifications:\n      props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0\n        ? props.queriesQualifications\n        : undefined,\n  };\n}\n\nexport function createDiscoveredPColumnId(props: {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}): DiscoveredPColumnId {\n  return stringifyDiscoveredPColumnId(props);\n}\n\nexport function parseDiscoveredPColumnId(id: DiscoveredPColumnId): DiscoveredPColumn {\n  try {\n    const parsed = JSON.parse(id);\n    return isDiscoveredPColumn(parsed)\n      ? parsed\n      : throwError(\"Parsed object is not a valid DiscoveredPColumn\");\n  } catch {\n    throw new Error(\n      \"Invalid DiscoveredPColumnId: not a valid JSON or does not conform to DiscoveredPColumn structure\",\n    );\n  }\n}\n\nexport function stringifyDiscoveredPColumnId(id: DiscoveredPColumn) {\n  return canonicalizeJson<DiscoveredPColumn>(\n    distillDiscoveredPColumn(id),\n  ) as string as DiscoveredPColumnId;\n}\n"],"mappings":";;;AAmBA,SAAgB,oBAAoB,KAAwC;AAC1E,QACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,YAAY,OACZ,0BAA0B,OAC1B,2BAA2B;;AAI/B,SAAgB,yBAAyB,OAA6C;AACpF,QAAO;EACL,QAAQ,MAAM;EACd,MAAM,MAAM,QAAQ,MAAM,KAAK,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO,KAAA;EACxE,sBACE,MAAM,QAAQ,MAAM,qBAAqB,IAAI,MAAM,qBAAqB,SAAS,IAC7E,MAAM,uBACN,KAAA;EACN,uBACE,MAAM,yBAAyB,OAAO,KAAK,MAAM,sBAAsB,CAAC,SAAS,IAC7E,MAAM,wBACN,KAAA;EACP;;AAGH,SAAgB,0BAA0B,OAKlB;AACtB,QAAO,6BAA6B,MAAM;;AAG5C,SAAgB,yBAAyB,IAA4C;AACnF,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,SAAO,oBAAoB,OAAO,GAC9B,SACA,WAAW,iDAAiD;SAC1D;AACN,QAAM,IAAI,MACR,mGACD;;;AAIL,SAAgB,6BAA6B,IAAuB;AAClE,QAAO,iBACL,yBAAyB,GAAG,CAC7B"}
+{"version":3,"file":"discovered_column.js","names":[],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"sourcesContent":["import { Branded, throwError } from \"@milaboratories/helpers\";\nimport { PObjectId } from \"../../../pool\";\nimport { AxisQualification } from \"./selectors\";\nimport { canonicalizeJson } from \"../../../json\";\n\nexport type DiscoveredPColumn = {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n};\n\nexport type DiscoveredPColumnId = Branded<PObjectId, \"DiscoveredPColumnId\">; // CanonicalizedJson<DiscoveredPColumn>;\n\ntype PathItem = {\n  type: \"linker\";\n  column: PObjectId;\n};\n\nexport function isDiscoveredPColumn(obj: unknown): obj is DiscoveredPColumn {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"path\" in obj &&\n    \"column\" in obj &&\n    \"columnQualifications\" in obj &&\n    \"queriesQualifications\" in obj\n  );\n}\n\nexport function distillDiscoveredPColumn(props: DiscoveredPColumn): DiscoveredPColumn {\n  return {\n    column: props.column,\n    path: Array.isArray(props.path) && props.path.length > 0 ? props.path : undefined,\n    columnQualifications:\n      Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0\n        ? props.columnQualifications\n        : undefined,\n    queriesQualifications:\n      props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0\n        ? props.queriesQualifications\n        : undefined,\n  };\n}\n\nexport function createDiscoveredPColumnId(props: {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}): DiscoveredPColumnId {\n  return stringifyDiscoveredPColumnId(props);\n}\n\nexport function parseDiscoveredPColumnId(id: DiscoveredPColumnId): DiscoveredPColumn {\n  try {\n    const parsed = JSON.parse(id);\n    return isDiscoveredPColumn(parsed)\n      ? parsed\n      : throwError(\"Parsed object is not a valid DiscoveredPColumn\");\n  } catch {\n    throw new Error(\n      \"Invalid DiscoveredPColumnId: not a valid JSON or does not conform to DiscoveredPColumn structure\",\n    );\n  }\n}\n\nexport function stringifyDiscoveredPColumnId(id: DiscoveredPColumn) {\n  return canonicalizeJson<DiscoveredPColumn>(\n    distillDiscoveredPColumn(id),\n  ) as string as DiscoveredPColumnId;\n}\n"],"mappings":";;;AAmBA,SAAgB,oBAAoB,KAAwC;CAC1E,OACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,YAAY,OACZ,0BAA0B,OAC1B,2BAA2B;AAE/B;AAEA,SAAgB,yBAAyB,OAA6C;CACpF,OAAO;EACL,QAAQ,MAAM;EACd,MAAM,MAAM,QAAQ,MAAM,IAAI,KAAK,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO,KAAA;EACxE,sBACE,MAAM,QAAQ,MAAM,oBAAoB,KAAK,MAAM,qBAAqB,SAAS,IAC7E,MAAM,uBACN,KAAA;EACN,uBACE,MAAM,yBAAyB,OAAO,KAAK,MAAM,qBAAqB,CAAC,CAAC,SAAS,IAC7E,MAAM,wBACN,KAAA;CACR;AACF;AAEA,SAAgB,0BAA0B,OAKlB;CACtB,OAAO,6BAA6B,KAAK;AAC3C;AAEA,SAAgB,yBAAyB,IAA4C;CACnF,IAAI;EACF,MAAM,SAAS,KAAK,MAAM,EAAE;EAC5B,OAAO,oBAAoB,MAAM,IAC7B,SACA,WAAW,gDAAgD;CACjE,QAAQ;EACN,MAAM,IAAI,MACR,kGACF;CACF;AACF;AAEA,SAAgB,6BAA6B,IAAuB;CAClE,OAAO,iBACL,yBAAyB,EAAE,CAC7B;AACF"}

package/dist/drivers/pframe/spec/filtered_column.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"filtered_column.cjs","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"sourcesContent":["import type { AnchoredPColumnId } from \"./selectors\";\n\n/** Value of an axis filter */\nexport type AxisFilterValue = number | string;\n\n/** Axis filter by index */\nexport type AxisFilterByIdx = [number, AxisFilterValue];\n\n/** Axis filter by name */\nexport type AxisFilterByName = [string, AxisFilterValue];\n\n/** Axis filter */\nexport type AxisFilter = AxisFilterByIdx | AxisFilterByName;\n\n/**\n * Identifies a column derived from a CanonicalPColumnId by fixing values on certain axes,\n * thus effectively reducing the dimensionality of the original column.\n */\nexport type FilteredPColumn<CID = AnchoredPColumnId, AFI = AxisFilter> = {\n  /** The original column identifier */\n  source: CID;\n\n  /**\n   * List of fixed axes and their corresponding values.\n   * Each entry fixes one axis to a specific value, creating a slice of the multidimensional data.\n   * This effectively reduces the dimensionality by one for each fixed axis.\n   * Ordered by the axis index in canonical case.\n   */\n  axisFilters: AFI[];\n};\n\nexport type FilteredPColumnId = FilteredPColumn<AnchoredPColumnId, AxisFilterByIdx>;\n\n/**\n * Checks if a given value is a FilteredPColumn\n * @param id - The value to check\n * @returns True if the value is a FilteredPColumn, false otherwise\n */\nexport function isFilteredPColumn(id: unknown): id is FilteredPColumn {\n  return typeof id === \"object\" && id !== null && \"source\" in id && \"axisFilters\" in id;\n}\n"],"mappings":";;;;;;AAsCA,SAAgB,kBAAkB,IAAoC;AACpE,QAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,YAAY,MAAM,iBAAiB"}
+{"version":3,"file":"filtered_column.cjs","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"sourcesContent":["import type { AnchoredPColumnId } from \"./selectors\";\n\n/** Value of an axis filter */\nexport type AxisFilterValue = number | string;\n\n/** Axis filter by index */\nexport type AxisFilterByIdx = [number, AxisFilterValue];\n\n/** Axis filter by name */\nexport type AxisFilterByName = [string, AxisFilterValue];\n\n/** Axis filter */\nexport type AxisFilter = AxisFilterByIdx | AxisFilterByName;\n\n/**\n * Identifies a column derived from a CanonicalPColumnId by fixing values on certain axes,\n * thus effectively reducing the dimensionality of the original column.\n */\nexport type FilteredPColumn<CID = AnchoredPColumnId, AFI = AxisFilter> = {\n  /** The original column identifier */\n  source: CID;\n\n  /**\n   * List of fixed axes and their corresponding values.\n   * Each entry fixes one axis to a specific value, creating a slice of the multidimensional data.\n   * This effectively reduces the dimensionality by one for each fixed axis.\n   * Ordered by the axis index in canonical case.\n   */\n  axisFilters: AFI[];\n};\n\nexport type FilteredPColumnId = FilteredPColumn<AnchoredPColumnId, AxisFilterByIdx>;\n\n/**\n * Checks if a given value is a FilteredPColumn\n * @param id - The value to check\n * @returns True if the value is a FilteredPColumn, false otherwise\n */\nexport function isFilteredPColumn(id: unknown): id is FilteredPColumn {\n  return typeof id === \"object\" && id !== null && \"source\" in id && \"axisFilters\" in id;\n}\n"],"mappings":";;;;;;AAsCA,SAAgB,kBAAkB,IAAoC;CACpE,OAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,YAAY,MAAM,iBAAiB;AACrF"}

package/dist/drivers/pframe/spec/filtered_column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filtered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"mappings":";;;;KAGY,eAAA;AAAZ;AAAA,KAGY,eAAA,YAA2B,eAAA;;KAG3B,gBAAA,YAA4B,eAAA;;KAG5B,UAAA,GAAa,eAAA,GAAkB,gBAAA;;;;;KAM/B,eAAA,OAAsB,iBAAA,QAAyB,UAAA;EAT/B,qCAW1B,MAAA,EAAQ,GAAA;EAX8B;;AAGxC;;;;EAgBE,WAAA,EAAa,GAAA;AAAA;AAAA,KAGH,iBAAA,GAAoB,eAAA,CAAgB,iBAAA,EAAmB,eAAA;;;;;;iBAOnD,iBAAA,CAAkB,EAAA,YAAc,EAAA,IAAM,eAAA"}
+{"version":3,"file":"filtered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"mappings":";;;;KAGY,eAAA;AAAZ;AAAA,KAGY,eAAA,YAA2B,eAAe;;KAG1C,gBAAA,YAA4B,eAAe;AAN5B;AAAA,KASf,UAAA,GAAa,eAAA,GAAkB,gBAAgB;;;;AANL;KAY1C,eAAA,OAAsB,iBAAA,QAAyB,UAAA;EAT/B,qCAW1B,MAAA,EAAQ,GAAA;EAX6C;AAAA;AAGvD;;;;EAgBE,WAAA,EAAa,GAAA;AAAA;AAAA,KAGH,iBAAA,GAAoB,eAAA,CAAgB,iBAAA,EAAmB,eAAA;;;;;;iBAOnD,iBAAA,CAAkB,EAAA,YAAc,EAAA,IAAM,eAAe"}

package/dist/drivers/pframe/spec/filtered_column.js.map

@@ -1 +1 @@
-{"version":3,"file":"filtered_column.js","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"sourcesContent":["import type { AnchoredPColumnId } from \"./selectors\";\n\n/** Value of an axis filter */\nexport type AxisFilterValue = number | string;\n\n/** Axis filter by index */\nexport type AxisFilterByIdx = [number, AxisFilterValue];\n\n/** Axis filter by name */\nexport type AxisFilterByName = [string, AxisFilterValue];\n\n/** Axis filter */\nexport type AxisFilter = AxisFilterByIdx | AxisFilterByName;\n\n/**\n * Identifies a column derived from a CanonicalPColumnId by fixing values on certain axes,\n * thus effectively reducing the dimensionality of the original column.\n */\nexport type FilteredPColumn<CID = AnchoredPColumnId, AFI = AxisFilter> = {\n  /** The original column identifier */\n  source: CID;\n\n  /**\n   * List of fixed axes and their corresponding values.\n   * Each entry fixes one axis to a specific value, creating a slice of the multidimensional data.\n   * This effectively reduces the dimensionality by one for each fixed axis.\n   * Ordered by the axis index in canonical case.\n   */\n  axisFilters: AFI[];\n};\n\nexport type FilteredPColumnId = FilteredPColumn<AnchoredPColumnId, AxisFilterByIdx>;\n\n/**\n * Checks if a given value is a FilteredPColumn\n * @param id - The value to check\n * @returns True if the value is a FilteredPColumn, false otherwise\n */\nexport function isFilteredPColumn(id: unknown): id is FilteredPColumn {\n  return typeof id === \"object\" && id !== null && \"source\" in id && \"axisFilters\" in id;\n}\n"],"mappings":";;;;;;AAsCA,SAAgB,kBAAkB,IAAoC;AACpE,QAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,YAAY,MAAM,iBAAiB"}
+{"version":3,"file":"filtered_column.js","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"sourcesContent":["import type { AnchoredPColumnId } from \"./selectors\";\n\n/** Value of an axis filter */\nexport type AxisFilterValue = number | string;\n\n/** Axis filter by index */\nexport type AxisFilterByIdx = [number, AxisFilterValue];\n\n/** Axis filter by name */\nexport type AxisFilterByName = [string, AxisFilterValue];\n\n/** Axis filter */\nexport type AxisFilter = AxisFilterByIdx | AxisFilterByName;\n\n/**\n * Identifies a column derived from a CanonicalPColumnId by fixing values on certain axes,\n * thus effectively reducing the dimensionality of the original column.\n */\nexport type FilteredPColumn<CID = AnchoredPColumnId, AFI = AxisFilter> = {\n  /** The original column identifier */\n  source: CID;\n\n  /**\n   * List of fixed axes and their corresponding values.\n   * Each entry fixes one axis to a specific value, creating a slice of the multidimensional data.\n   * This effectively reduces the dimensionality by one for each fixed axis.\n   * Ordered by the axis index in canonical case.\n   */\n  axisFilters: AFI[];\n};\n\nexport type FilteredPColumnId = FilteredPColumn<AnchoredPColumnId, AxisFilterByIdx>;\n\n/**\n * Checks if a given value is a FilteredPColumn\n * @param id - The value to check\n * @returns True if the value is a FilteredPColumn, false otherwise\n */\nexport function isFilteredPColumn(id: unknown): id is FilteredPColumn {\n  return typeof id === \"object\" && id !== null && \"source\" in id && \"axisFilters\" in id;\n}\n"],"mappings":";;;;;;AAsCA,SAAgB,kBAAkB,IAAoC;CACpE,OAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,YAAY,MAAM,iBAAiB;AACrF"}

package/dist/drivers/pframe/spec/ids.cjs

@@ -1,6 +1,6 @@
 const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
 let canonicalize = require("canonicalize");
-canonicalize = require_runtime.__toESM(canonicalize);
+canonicalize = require_runtime.__toESM(canonicalize, 1);
 //#region src/drivers/pframe/spec/ids.ts
 /**
 * Canonically serializes a {@link UniversalPColumnId} to a string.

package/dist/drivers/pframe/spec/ids.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ids.cjs","names":[],"sources":["../../../../src/drivers/pframe/spec/ids.ts"],"sourcesContent":["import type { Branded } from \"../../../branding\";\nimport type { AnchoredPColumnId } from \"./selectors\";\nimport type { FilteredPColumnId } from \"./filtered_column\";\nimport canonicalize from \"canonicalize\";\nimport type { PObjectId } from \"../../../pool\";\nimport { DiscoveredPColumn } from \"./discovered_column\";\n\n/**\n * Universal column identifier optionally anchored and optionally filtered.\n */\nexport type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId | DiscoveredPColumn;\n\n/**\n * Canonically serialized {@link UniversalPColumnId}.\n */\nexport type SUniversalPColumnId = Branded<PObjectId, \"SUniversalPColumnId\", \"__pl_model_brand_2__\">;\n\n/**\n * Canonically serializes a {@link UniversalPColumnId} to a string.\n * @param id - The column identifier to serialize\n * @returns The canonically serialized string\n */\nexport function stringifyColumnId(id: UniversalPColumnId): SUniversalPColumnId {\n  return canonicalize(id)! as SUniversalPColumnId;\n}\n\n/**\n * Parses a canonically serialized {@link UniversalPColumnId} from a string.\n * @param str - The string to parse\n * @returns The parsed column identifier\n */\nexport function parseColumnId(str: SUniversalPColumnId): UniversalPColumnId {\n  return JSON.parse(str) as UniversalPColumnId;\n}\n"],"mappings":";;;;;;;;;AAsBA,SAAgB,kBAAkB,IAA6C;AAC7E,SAAA,GAAA,aAAA,SAAoB,GAAG;;;;;;;AAQzB,SAAgB,cAAc,KAA8C;AAC1E,QAAO,KAAK,MAAM,IAAI"}
+{"version":3,"file":"ids.cjs","names":[],"sources":["../../../../src/drivers/pframe/spec/ids.ts"],"sourcesContent":["import type { Branded } from \"../../../branding\";\nimport type { AnchoredPColumnId } from \"./selectors\";\nimport type { FilteredPColumnId } from \"./filtered_column\";\nimport canonicalize from \"canonicalize\";\nimport type { PObjectId } from \"../../../pool\";\nimport { DiscoveredPColumn } from \"./discovered_column\";\n\n/**\n * Universal column identifier optionally anchored and optionally filtered.\n */\nexport type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId | DiscoveredPColumn;\n\n/**\n * Canonically serialized {@link UniversalPColumnId}.\n */\nexport type SUniversalPColumnId = Branded<PObjectId, \"SUniversalPColumnId\", \"__pl_model_brand_2__\">;\n\n/**\n * Canonically serializes a {@link UniversalPColumnId} to a string.\n * @param id - The column identifier to serialize\n * @returns The canonically serialized string\n */\nexport function stringifyColumnId(id: UniversalPColumnId): SUniversalPColumnId {\n  return canonicalize(id)! as SUniversalPColumnId;\n}\n\n/**\n * Parses a canonically serialized {@link UniversalPColumnId} from a string.\n * @param str - The string to parse\n * @returns The parsed column identifier\n */\nexport function parseColumnId(str: SUniversalPColumnId): UniversalPColumnId {\n  return JSON.parse(str) as UniversalPColumnId;\n}\n"],"mappings":";;;;;;;;;AAsBA,SAAgB,kBAAkB,IAA6C;CAC7E,QAAA,GAAA,aAAA,QAAA,CAAoB,EAAE;AACxB;;;;;;AAOA,SAAgB,cAAc,KAA8C;CAC1E,OAAO,KAAK,MAAM,GAAG;AACvB"}

package/dist/drivers/pframe/spec/ids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ids.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/ids.ts"],"mappings":";;;;;;;;;KAUY,kBAAA,GAAqB,iBAAA,GAAoB,iBAAA,GAAoB,iBAAA;;;;KAK7D,mBAAA,GAAsB,OAAA,CAAQ,SAAA;;;;;;iBAO1B,iBAAA,CAAkB,EAAA,EAAI,kBAAA,GAAqB,mBAAA;;;AAP3D;;;iBAgBgB,aAAA,CAAc,GAAA,EAAK,mBAAA,GAAsB,kBAAA"}
+{"version":3,"file":"ids.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/ids.ts"],"mappings":";;;;;;;;;KAUY,kBAAA,GAAqB,iBAAA,GAAoB,iBAAA,GAAoB,iBAAA;;;;KAK7D,mBAAA,GAAsB,OAAO,CAAC,SAAA;;;;;;iBAO1B,iBAAA,CAAkB,EAAA,EAAI,kBAAA,GAAqB,mBAAmB;;AAZY;AAK1F;;;iBAgBgB,aAAA,CAAc,GAAA,EAAK,mBAAA,GAAsB,kBAAkB"}