Kyle Simpson getify

## gist:1b26accb1a09aa53ad25
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Worker Polyfill</title>
<script src="polyfill.worker.js"></script>
</head>
<body>
<h1>Worker Polyfill</h1>
<script>

## 1.md

      
              1 file
            
          
              0 forks
            
          
              2 comments
            
          
              2 stars
            
          
                getify
                / 1.md
            
            
              Last active
              March 23, 2024 16:16
            
              
                describing a bundling question in detail
              
          
    I'm the author of an npm package that comes as a single ESM-format module, let's call it "A". This package is only a client-side (browser) library, it will not work in Node -- it interacts with client-only web platform APIs.
The "A" package doesn't use any typical build tools (typescript, webpack/vite, etc). But it does include a simple "publish-build" script that's used at npm publish time to prepare a dist/ directory for the package.
The package relies on three npm package dependencies (call them "B", "C", and "D"), which I do not own/control. These 3 packages only distribute themselves as plain .js window-global style scripts. They cannot be imported, because (unfortunately) they make assumptions about global-scope this (being window), non-strict mode, etc. That also means they can't just be inlined into the "A" distribution module file.
Moreover, these dependencies are big enough (and potentially useful enough) that a user of "A" might also want to access and use "B", "C", or "D" functi

  
## 1-CalendarItem.js
// abstract class, not intended to be instantiated directly
class CalendarItem {
    static #UNSET = Symbol("unset")
    static #isUnset(v) {
        return v === this.#UNSET;
    }
    static {
        for (let [idx,msg] of [
            "ID is already set.",
            "ID is unset.",

## a0.js
var ASQ = require("asynquence-contrib");


ASQ()
.runner(
	ASQ.csp.go(function*(ch){
		yield ASQ.csp.put(ch,1);
		yield ASQ.csp.take( ASQ.csp.timeout(1000) );
		console.log( "a", yield ASQ.csp.take( ch ) );
	}),

## gist:5226305
// `Object.make(..)` is a helper/wrapper for `Object.create(..)`. Both create a new
// object, and optionally link that new object's `[[Prototype]]` chain to another object.
//
// But `Object.make(..)` makes sure the new object always has a `__proto__` property
// (even a null one) and delegation to a `isPrototypeOf(..)` method, both of which are
// missing from the bare object (aka "Dictionary") created by `Object.create(null)`.
//
// `isPrototypeOf()` is put on a extra object that your created object can delegate to,
// if any only if you create an empty object (by not passing a `linkTo`) that otherwise
// wouldn't have access to `isPrototypeOf()`.

## gist:5285514

      
              1 file
            
          
              1 fork
            
          
              0 comments
            
          
              8 stars
            
          
                getify
                / gist:5285514
            
            
              Last active
              January 7, 2024 11:58
            
              
                since `let (foo = 42) { ... }` is not coming to ES6 after all...
              
          
    I hereby propose this form of let usage as the next best option, since the clearly better let (foo = 42) { ... } let-block-statement syntax is dead and not coming to ES6:
/*let*/ { let foo = 42;

   // your code that uses `foo`

}

  
## ex1-prototype-style.js
function Foo(who) {
	this.me = who;
}

Foo.prototype.identify = function() {
	return "I am " + this.me;
};

function Bar(who) {
	Foo.call(this,"Bar:" + who);

## 1.js
var r = Reader();

console.log(
  r
  .map(env => ({ ...env, y: 2 }))
  .chain(env => Reader(() => ({ ...env, z: 3 })))
  .evaluate({ x: 1 })
);
// { x: 1, y: 2, z: 3 }

## 1-setup.js
// Adapted from: https://www.geeksforgeeks.org/find-length-largest-region-boolean-matrix/

"use strict";

var M1 = [
	[ 0, 0, 1, 1, 0 ],
	[ 1, 0, 1, 1, 0 ],
	[ 0, 1, 0, 0, 0 ],
	[ 0, 0, 0, 1, 1 ]
];

## 1.js
// note: this uses proposed JS syntax for pipeline operator: https://github.com/tc39/proposal-pipeline-operator

// CHARACTER STATS (code comments and their padded whitespace ignored)...
//   letters, numbers (a-z A-Z 0-9): 317
//   non-letters-non-whitespace: 138
//     simple symbols (+ - * / . " : ( ) [ ] { } , =): 94
//     compound symbols (=> ?? ?. |> %%): 15 (30 chars)
//     optional semicolons: 14
//   whitespace: 90
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	<title>Worker Polyfill</title>
	<script src="polyfill.worker.js"></script>
	</head>
	<body>
	<h1>Worker Polyfill</h1>
	<script>
	// abstract class, not intended to be instantiated directly
	class CalendarItem {
	static #UNSET = Symbol("unset")
	static #isUnset(v) {
	return v === this.#UNSET;
	}
	static {
	for (let [idx,msg] of [
	"ID is already set.",
	"ID is unset.",
	var ASQ = require("asynquence-contrib");


	ASQ()
	.runner(
	ASQ.csp.go(function*(ch){
	yield ASQ.csp.put(ch,1);
	yield ASQ.csp.take( ASQ.csp.timeout(1000) );
	console.log( "a", yield ASQ.csp.take( ch ) );
	}),
	// `Object.make(..)` is a helper/wrapper for `Object.create(..)`. Both create a new
	// object, and optionally link that new object's `[[Prototype]]` chain to another object.
	//
	// But `Object.make(..)` makes sure the new object always has a `__proto__` property
	// (even a null one) and delegation to a `isPrototypeOf(..)` method, both of which are
	// missing from the bare object (aka "Dictionary") created by `Object.create(null)`.
	//
	// `isPrototypeOf()` is put on a extra object that your created object can delegate to,
	// if any only if you create an empty object (by not passing a `linkTo`) that otherwise
	// wouldn't have access to `isPrototypeOf()`.
	function Foo(who) {
	this.me = who;
	}

	Foo.prototype.identify = function() {
	return "I am " + this.me;
	};

	function Bar(who) {
	Foo.call(this,"Bar:" + who);
	var r = Reader();

	console.log(
	r
	.map(env => ({ ...env, y: 2 }))
	.chain(env => Reader(() => ({ ...env, z: 3 })))
	.evaluate({ x: 1 })
	);
	// { x: 1, y: 2, z: 3 }
	// Adapted from: https://www.geeksforgeeks.org/find-length-largest-region-boolean-matrix/

	"use strict";

	var M1 = [
	[ 0, 0, 1, 1, 0 ],
	[ 1, 0, 1, 1, 0 ],
	[ 0, 1, 0, 0, 0 ],
	[ 0, 0, 0, 1, 1 ]
	];
	// note: this uses proposed JS syntax for pipeline operator: https://github.com/tc39/proposal-pipeline-operator

	// CHARACTER STATS (code comments and their padded whitespace ignored)...
	// letters, numbers (a-z A-Z 0-9): 317
	// non-letters-non-whitespace: 138
	// simple symbols (+ - * / . " : ( ) [ ] { } , =): 94
	// compound symbols (=> ?? ?. \|> %%): 15 (30 chars)
	// optional semicolons: 14
	// whitespace: 90